Documentation

Overview

    Package registry is an interface for service discovery

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	// 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

    This section is empty.

    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, ...}

                  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"`
                    }

                    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.

                        Directories

                        Path Synopsis
                        Package cache provides a registry cache
                        Package cache provides a registry cache
                        Package etcd provides an etcd service registry
                        Package etcd provides an etcd service registry
                        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
                        Package service uses the registry service
                        Package service uses the registry service