Documentation

Overview

    Package mdns is a multicast dns registry

    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 Services

                  func Services(s map[string][]*Service) Option

                    Services is an option that preloads service data

                    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 NewMemoryRegistry

                        func NewMemoryRegistry(opts ...Option) Registry

                        func NewRegistry

                        func NewRegistry(opts ...Option) Registry

                          NewRegistry returns a new default registry which is mdns

                          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 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