filter

README

Filter

Getting Started

Recommended Way: import what you needs, see also dubbo-go/imports.

package demo

// use echo and generic filters
import _ "dubbo.apache.org/dubbo-go/v3/filter/echo"
import _ "dubbo.apache.org/dubbo-go/v3/filter/generic"

Legacy way: import all filters by one line.

package demo

import _ "dubbo.apache.org/dubbo-go/v3/filter/filter_impl"

Contents

• accesslog: Access Log Filter(https://github.com/apache/dubbo-go/pull/214)
• active
• auth: Auth/Sign Filter(https://github.com/apache/dubbo-go/pull/323)
• echo: Echo Health Check Filter
• execlmt: Execute Limit Filter(https://github.com/apache/dubbo-go/pull/246)
• generic: Generic Filter(https://github.com/apache/dubbo-go/pull/291)
• gshutdown: Graceful Shutdown Filter
• hystrix: Hystric Filter(https://github.com/apache/dubbo-go/pull/133)
• metrics: Metrics Filter(https://github.com/apache/dubbo-go/pull/342)
• seata: Seata Filter
• sentinel: Sentinel Filter
• token: Token Filter(https://github.com/apache/dubbo-go/pull/202)
• tps: Tps Limit Filter(https://github.com/apache/dubbo-go/pull/237)
• tracing: Tracing Filter(https://github.com/apache/dubbo-go/pull/335)

Documentation

Overview

Package filter defines the functions of a filter.

• please register your implementation by invoking SetTpsLimitStrategy
• "UserProvider":
• registry: "hangzhouzk"
• protocol : "dubbo"
• interface : "com.ikurento.user.UserProvider"
• ... # other configuration
• tps.limiter: "method-service" # the name of limiter
• tps.limit.strategy: "name of implementation" # service-level
• methods:
• - name: "GetUser"
• tps.interval: 3000
• tps.limit.strategy: "name of implementation" # method-level

Index

• type AccessKeyPair
• type AccessKeyStorage
• type Authenticator
• type Filter
• type RejectedExecutionHandler
• type TpsLimitStrategy
• type TpsLimitStrategyCreator
• type TpsLimiter

Types

type AccessKeyPair

type AccessKeyPair struct {
	AccessKey    string `yaml:"accessKey"   json:"accessKey,omitempty" property:"accessKey"`
	SecretKey    string `yaml:"secretKey"   json:"secretKey,omitempty" property:"secretKey"`
	ConsumerSide string `yaml:"consumerSide"   json:"consumerSide,omitempty" property:"consumerSide"`
	ProviderSide string `yaml:"providerSide"   json:"providerSide,omitempty" property:"providerSide"`
	Creator      string `yaml:"creator"   json:"creator,omitempty" property:"creator"`
	Options      string `yaml:"options"   json:"options,omitempty" property:"options"`
}

AccessKeyPair stores the basic attributes for authentication.

type AccessKeyStorage

type AccessKeyStorage interface {
	GetAccessKeyPair(protocol.Invocation, *common.URL) *AccessKeyPair
}

AccessKeyStorage is the interface which supports us to store our AccessKeyPair or load AccessKeyPair from other storage, such as filesystem.

type Authenticator

type Authenticator interface {

	// Sign adds signature to the invocation
	Sign(protocol.Invocation, *common.URL) error

	// Authenticate verifies the signature of the request
	Authenticate(protocol.Invocation, *common.URL) error
}

Authenticator is the interface which defines how an Authenticator works. Custom Authenticator must be set by calling auth.SetAuthenticator before use.

type Filter

type Filter interface {
	Invoke(context.Context, protocol.Invoker, protocol.Invocation) protocol.Result
	OnResponse(context.Context, protocol.Result, protocol.Invoker, protocol.Invocation) protocol.Result
}

Filter is the interface which wraps Invoke and OnResponse method and defines the functions of a filter. Invoke method is the core function of a filter, it determines the process of the filter. OnResponse method updates the results from Invoke and then returns the modified results.

type RejectedExecutionHandler

type RejectedExecutionHandler interface {
	RejectedExecution(url *common.URL, invocation protocol.Invocation) protocol.Result
}

RejectedExecutionHandler is the interface which defines the handler to handle exceptions from invoking filters. If the invocation cannot pass any validation in filter, like ExecuteLimitFilter and TpsLimitFilter, the implementation will be used. The common case is that sometimes you want to return the default value when the request was rejected. Or you want to be warned if any request was rejected. In such situation, implement this interface and register it by invoking extension.SetRejectedExecutionHandler.

RejectedExecution method will be called if the invocation was rejected by some component.

type TpsLimitStrategy

type TpsLimitStrategy interface {
	IsAllowable() bool
}

TpsLimitStrategy is the interface which defines how to do the TPS limiting in method level.

IsAllowable will return true if this invocation is not over limitation.

type TpsLimitStrategyCreator

type TpsLimitStrategyCreator interface {
	// Create will create an instance of TpsLimitStrategy
	// It will be a little hard to understand this method.
	// The unit of interval is ms
	// for example, if the limit = 100, interval = 1000
	// which means that the limiter limitation is 100 times per 1000ms (100/1000ms)
	Create(limit int, interval int) TpsLimitStrategy
}

TpsLimitStrategyCreator is the interface which creates TpsLimitStrategy.

type TpsLimiter

type TpsLimiter interface {
	IsAllowable(*common.URL, protocol.Invocation) bool
}

TpsLimiter is the interface which defines the Limiter that judge if the TPS overs the threshold

IsAllowable method will check whether this invocation should be enabled for further process

please register your implementation by invoking SetTpsLimiter The usage, for example: "UserProvider":

registry: "hangzhouzk"
protocol : "dubbo"
interface : "com.ikurento.user.UserProvider"
... # other configuration
tps.limiter: "the name of limiter",