selector

Documentation

Overview

The Selector package provides a way to algorithmically filter and return nodes required by the client or any other system. Selector's implemented by Micro build on the registry but it's of optional use. One could provide a static Selector that has a fixed pool.

func (r *randomSelector) Select(service string, opts ...SelectOption) (Next, error) {
	var sopts SelectOptions
	for _, opt := range opts {
		opt(&sopts)
	}

	// get the service
	services, err := r.so.Registry.GetService(service)
	if err != nil {
		return nil, err
	}

	// apply the filters
	for _, filter := range sopts.Filters {
		services = filter(services)
	}

	// if there's nothing left, return
	if len(services) == 0 {
		return nil, ErrNotFound
	}

	var nodes []*registry.Node

	for _, service := range services {
		for _, node := range service.Nodes {
			nodes = append(nodes, node)
		}
	}

	if len(nodes) == 0 {
		return nil, ErrNotFound
	}

	return func() (*registry.Node, error) {
		i := rand.Int()
		j := i % len(services)

		if len(services[j].Nodes) == 0 {
			return nil, ErrNotFound
		}

		k := i % len(services[j].Nodes)
		return services[j].Nodes[k], nil
	}, nil
}

Index

• Variables
• type Next
• type Option
  • func Registry(r registry.Registry) Option
• type Options
• type SelectFilter
• type SelectOption
  • func Filter(fn SelectFilter) SelectOption
• type SelectOptions
• type Selector
  • func NewSelector(opts ...Option) Selector

Variables

var (
	DefaultSelector = newRandomSelector()

	ErrNotFound      = errors.New("not found")
	ErrNoneAvailable = errors.New("none available")
)

Types

type Next

type Next func() (*registry.Node, error)

Next is a function that returns the next node based on the selector's algorithm

type Option

type Option func(*Options)

Option used to initialise the selector

func Registry

func Registry(r registry.Registry) Option

Registry sets the registry used by the selector

type Options

type Options struct {
	Registry registry.Registry

	// Other options for implementations of the interface
	// can be stored in a context
	Context context.Context
}

type SelectFilter

type SelectFilter func([]*registry.Service) []*registry.Service

SelectFilter is used to filter a service during the selection process

type SelectOption

type SelectOption func(*SelectOptions)

SelectOption used when making a select call

func Filter

func Filter(fn SelectFilter) SelectOption

Filter adds a filter function to the list of filters used during the Select call.

type SelectOptions

type SelectOptions struct {
	Filters []SelectFilter

	// Other options for implementations of the interface
	// can be stored in a context
	Context context.Context
}

type Selector

type Selector interface {
	Init(opts ...Option) error
	Options() Options
	// Select returns a function which should return the next node
	Select(service string, opts ...SelectOption) (Next, error)
	// Mark sets the success/error against a node
	Mark(service string, node *registry.Node, err error)
	// Reset returns state back to zero for a service
	Reset(service string)
	// Close renders the selector unusable
	Close() error
	// Name of the selector
	String() string
}

Selector builds on the registry as a mechanism to pick nodes and mark their status. This allows host pools and other things to be built using various algorithms.

func NewSelector

func NewSelector(opts ...Option) Selector