router

Documentation

Index

• type AddrMetadata
• type AddrPool
• type BaseRouterRule
• type Cache
• type Chain
• type ConnChecker
• type FilePriorityRouterFactory
• type HealthChecker
• type Poolable
• type PriorityRouter
• type PriorityRouterDetecter
• type PriorityRouterFactory
• type RouteSnapshot
  • func (rs *RouteSnapshot) AddRouteSnapshot(msg string)

Types

type AddrMetadata

type AddrMetadata interface {
	// Source indicates where the metadata comes from.
	Source() string
}

AddrMetadta is address metadata, collected from a snapshot of address list by a router, if it implements Poolable.

type AddrPool

type AddrPool map[string]*roaring.Bitmap

AddrPool is an address pool, backed by a snapshot of address list, divided into categories.

type BaseRouterRule

type BaseRouterRule struct {
	RawRule  string
	Runtime  bool
	Force    bool
	Valid    bool
	Enabled  bool
	Priority int
	Dynamic  bool
	Scope    string
	Key      string
}

BaseRouterRule

type Cache

type Cache interface {
	// GetInvokers returns the snapshot of received invokers.
	GetInvokers() []protocol.Invoker

	// FindAddrPool returns address pool associated with the given Poolable instance.
	FindAddrPool(Poolable) AddrPool

	// FindAddrMeta returns address metadata associated with the given Poolable instance.
	FindAddrMeta(Poolable) AddrMetadata
}

Cache caches all addresses relevant info for a snapshot of received invokers. It keeps a snapshot of the received address list, and also keeps address pools and address metadata from routers based on the same address snapshot, if the router implements Poolable.

type Chain

type Chain interface {
	Route(*common.URL, protocol.Invocation) []protocol.Invoker
	// Refresh invokers
	SetInvokers([]protocol.Invoker)
	// AddRouters Add routers
	AddRouters([]PriorityRouter)
	// GetNotifyChan get notify channel of this chain
	GetNotifyChan() chan struct{}
	// Detect Route State
	DetectRoute() (RouteSnapshot, error)
}

Chain

type ConnChecker

type ConnChecker interface {
	// IsConnHealthy evaluates the healthy state on the given Invoker
	IsConnHealthy(invoker protocol.Invoker) bool
}

ConnChecker is used to determine whether the invoker is healthy or not

type FilePriorityRouterFactory

type FilePriorityRouterFactory interface {
	// NewFileRouters Create file router with config file
	NewFileRouter([]byte) (PriorityRouter, error)
}

FilePriorityRouterFactory creates priority router with parse config file

type HealthChecker

type HealthChecker interface {
	// IsHealthy evaluates the healthy state on the given Invoker
	IsHealthy(invoker protocol.Invoker) bool
}

HealthChecker is used to determine whether the invoker is healthy or not

type Poolable

type Poolable interface {
	// Pool created address pool and address metadata from the invokers.
	Pool([]protocol.Invoker) (AddrPool, AddrMetadata)

	// ShouldPool returns if it should pool. One typical scenario is a router rule changes, in this case, a pooling
	// is necessary, even if the addresses not changed at all.
	ShouldPool() bool

	// Name return the Poolable's name.
	Name() string
}

Poolable caches address pool and address metadata for a router instance which will be used later in Router's Route.

type PriorityRouter

type PriorityRouter interface {

	// Priority Return Priority in router
	// 0 to ^int(0) is better
	Priority() int64
	// contains filtered or unexported methods
}

Router

type PriorityRouterDetecter

type PriorityRouterDetecter interface {
	RouteSnapshot(cache Cache) string
}

PriorityRouterDetecter detect the router

type PriorityRouterFactory

type PriorityRouterFactory interface {
	// NewPriorityRouter creates router instance with URL
	NewPriorityRouter(*common.URL, chan struct{}) (PriorityRouter, error)
}

Extension - Router PriorityRouterFactory creates creates priority router with url

type RouteSnapshot

type RouteSnapshot struct {
	Invokers       []protocol.Invoker
	RouteSnapshots []string
}

RouteSnapshot is the snapshot of Route

func (*RouteSnapshot) AddRouteSnapshot

func (rs *RouteSnapshot) AddRouteSnapshot(msg string)

nolint