Documentation

Overview

    Package registry is an interface for service discovery

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	DefaultRegistry = NewRegistry()
    
    	// Not found error when GetService is called
    	ErrNotFound = errors.New("service not found")
    	// Watcher stopped error when watcher is stopped
    	ErrWatcherStopped = errors.New("watcher stopped")
    )

    Functions

    func Deregister

    func Deregister(s *Service) error

      Deregister a service node

      func Register

      func Register(s *Service, opts ...RegisterOption) error

        Register a service node. Additionally supply options such as TTL.

        func String

        func String() string

        Types

        type DeregisterOption

        type DeregisterOption func(*DeregisterOptions)

        func DeregisterContext

        func DeregisterContext(ctx context.Context) DeregisterOption

        type DeregisterOptions

        type DeregisterOptions struct {
        	Context context.Context
        }

        type Endpoint

        type Endpoint struct {
        	Name     string            `json:"name"`
        	Request  *Value            `json:"request"`
        	Response *Value            `json:"response"`
        	Metadata map[string]string `json:"metadata"`
        }

        type Event

        type Event struct {
        	// Id is registry id
        	Id string
        	// Type defines type of event
        	Type EventType
        	// Timestamp is event timestamp
        	Timestamp time.Time
        	// Service is registry service
        	Service *Service
        }

          Event is registry event

          type EventType

          type EventType int

            EventType defines registry event type

            const (
            	// Create is emitted when a new service is registered
            	Create EventType = iota
            	// Delete is emitted when an existing service is deregsitered
            	Delete
            	// Update is emitted when an existing servicec is updated
            	Update
            )

            func (EventType) String

            func (t EventType) String() string

              String returns human readable event type

              type GetOption

              type GetOption func(*GetOptions)

              func GetContext

              func GetContext(ctx context.Context) GetOption

              type GetOptions

              type GetOptions struct {
              	Context context.Context
              }

              type ListOption

              type ListOption func(*ListOptions)

              func ListContext

              func ListContext(ctx context.Context) ListOption

              type ListOptions

              type ListOptions struct {
              	Context context.Context
              }

              type Node

              type Node struct {
              	Id       string            `json:"id"`
              	Address  string            `json:"address"`
              	Metadata map[string]string `json:"metadata"`
              }

              type Option

              type Option func(*Options)

              func Addrs

              func Addrs(addrs ...string) Option

                Addrs is the registry addresses to use

                func Secure

                func Secure(b bool) Option

                  Secure communication with the registry

                  func TLSConfig

                  func TLSConfig(t *tls.Config) Option

                    Specify TLS Config

                    func Timeout

                    func Timeout(t time.Duration) Option

                    type Options

                    type Options struct {
                    	Addrs     []string
                    	Timeout   time.Duration
                    	Secure    bool
                    	TLSConfig *tls.Config
                    	// Other options for implementations of the interface
                    	// can be stored in a context
                    	Context context.Context
                    }

                    type RegisterOption

                    type RegisterOption func(*RegisterOptions)

                    func RegisterContext

                    func RegisterContext(ctx context.Context) RegisterOption

                    func RegisterTTL

                    func RegisterTTL(t time.Duration) RegisterOption

                    type RegisterOptions

                    type RegisterOptions struct {
                    	TTL time.Duration
                    	// Other options for implementations of the interface
                    	// can be stored in a context
                    	Context context.Context
                    }

                    type Registry

                    type Registry interface {
                    	Init(...Option) error
                    	Options() Options
                    	Register(*Service, ...RegisterOption) error
                    	Deregister(*Service, ...DeregisterOption) error
                    	GetService(string, ...GetOption) ([]*Service, error)
                    	ListServices(...ListOption) ([]*Service, error)
                    	Watch(...WatchOption) (Watcher, error)
                    	String() string
                    }

                      The registry provides an interface for service discovery and an abstraction over varying implementations {consul, etcd, zookeeper, ...}

                      func NewRegistry

                      func NewRegistry(opts ...Option) Registry

                      type Result

                      type Result struct {
                      	Action  string
                      	Service *Service
                      }

                        Result is returned by a call to Next on the watcher. Actions can be create, update, delete

                        type Service

                        type Service struct {
                        	Name      string            `json:"name"`
                        	Version   string            `json:"version"`
                        	Metadata  map[string]string `json:"metadata"`
                        	Endpoints []*Endpoint       `json:"endpoints"`
                        	Nodes     []*Node           `json:"nodes"`
                        }

                        func CopyService

                        func CopyService(service *Service) *Service

                          CopyService make a copy of service

                          func GetService

                          func GetService(name string) ([]*Service, error)

                            Retrieve a service. A slice is returned since we separate Name/Version.

                            func ListServices

                            func ListServices() ([]*Service, error)

                              List the services. Only returns service names

                              type Value

                              type Value struct {
                              	Name   string   `json:"name"`
                              	Type   string   `json:"type"`
                              	Values []*Value `json:"values"`
                              }

                              type WatchOption

                              type WatchOption func(*WatchOptions)

                              func WatchContext

                              func WatchContext(ctx context.Context) WatchOption

                              func WatchService

                              func WatchService(name string) WatchOption

                                Watch a service

                                type WatchOptions

                                type WatchOptions struct {
                                	// Specify a service to watch
                                	// If blank, the watch is for all services
                                	Service string
                                	// Other options for implementations of the interface
                                	// can be stored in a context
                                	Context context.Context
                                }

                                type Watcher

                                type Watcher interface {
                                	// Next is a blocking call
                                	Next() (*Result, error)
                                	Stop()
                                }

                                  Watcher is an interface that returns updates about services within the registry.

                                  func Watch

                                  func Watch(opts ...WatchOption) (Watcher, error)

                                    Watch returns a watcher which allows you to track updates to the registry.

                                    Directories

                                    Path Synopsis
                                    Package cache provides a registry cache
                                    Package cache provides a registry cache
                                    Package mdns provides a multicast dns registry Package mdns is a multicast dns registry
                                    Package mdns provides a multicast dns registry Package mdns is a multicast dns registry
                                    Package memory provides an in-memory registry
                                    Package memory provides an in-memory registry
                                    Package service uses the registry service
                                    Package service uses the registry service