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("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 Endpoint

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

        type Node

        type Node struct {
        	Id       string            `json:"id"`
        	Address  string            `json:"address"`
        	Port     int               `json:"port"`
        	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 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) error
              	GetService(string) ([]*Service, error)
              	ListServices() ([]*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

                  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 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 Gossip provides a gossip registry based on hashicorp/memberlist
                              Package Gossip provides a gossip registry based on hashicorp/memberlist
                              proto
                              Package gossip is a generated protocol buffer package.
                              Package gossip is a generated protocol buffer package.
                              Package mdns provides a multicast dns registry
                              Package mdns provides a multicast dns registry
                              Package memory provides an in-memory registry
                              Package memory provides an in-memory registry