Documentation

Overview

    Package recipe contains experimental client-side distributed synchronization primitives.

    Index

    Constants

    This section is empty.

    Variables

    View Source
    var (
    	ErrKeyExists      = errors.New("key already exists")
    	ErrWaitMismatch   = errors.New("unexpected wait result")
    	ErrTooManyClients = errors.New("too many clients")
    	ErrNoWatcher      = errors.New("no watcher channel")
    )

    Functions

    func WaitEvents

    func WaitEvents(c *clientv3.Client, key string, rev int64, evs []mvccpb.Event_EventType) (*clientv3.Event, error)

      WaitEvents waits on a key until it observes the given events and returns the final one.

      func WaitPrefixEvents

      func WaitPrefixEvents(c *clientv3.Client, prefix string, rev int64, evs []mvccpb.Event_EventType) (*clientv3.Event, error)

      Types

      type Barrier

      type Barrier struct {
      	// contains filtered or unexported fields
      }

        Barrier creates a key in etcd to block processes, then deletes the key to release all blocked processes.

        func NewBarrier

        func NewBarrier(client *v3.Client, key string) *Barrier

        func (*Barrier) Hold

        func (b *Barrier) Hold() error

          Hold creates the barrier key causing processes to block on Wait.

          func (*Barrier) Release

          func (b *Barrier) Release() error

            Release deletes the barrier key to unblock all waiting processes.

            func (*Barrier) Wait

            func (b *Barrier) Wait() error

              Wait blocks on the barrier key until it is deleted. If there is no key, Wait assumes Release has already been called and returns immediately.

              type DoubleBarrier

              type DoubleBarrier struct {
              	// contains filtered or unexported fields
              }

                DoubleBarrier blocks processes on Enter until an expected count enters, then blocks again on Leave until all processes have left.

                func NewDoubleBarrier

                func NewDoubleBarrier(s *concurrency.Session, key string, count int) *DoubleBarrier

                func (*DoubleBarrier) Enter

                func (b *DoubleBarrier) Enter() error

                  Enter waits for "count" processes to enter the barrier then returns

                  func (*DoubleBarrier) Leave

                  func (b *DoubleBarrier) Leave() error

                    Leave waits for "count" processes to leave the barrier then returns

                    type EphemeralKV

                    type EphemeralKV struct{ RemoteKV }

                      EphemeralKV is a new key associated with a session lease

                      type PriorityQueue

                      type PriorityQueue struct {
                      	// contains filtered or unexported fields
                      }

                        PriorityQueue implements a multi-reader, multi-writer distributed queue.

                        func NewPriorityQueue

                        func NewPriorityQueue(client *v3.Client, key string) *PriorityQueue

                          NewPriorityQueue creates an etcd priority queue.

                          func (*PriorityQueue) Dequeue

                          func (q *PriorityQueue) Dequeue() (string, error)

                            Dequeue returns Enqueue()'d items in FIFO order. If the queue is empty, Dequeue blocks until items are available.

                            func (*PriorityQueue) Enqueue

                            func (q *PriorityQueue) Enqueue(val string, pr uint16) error

                              Enqueue puts a value into a queue with a given priority.

                              type Queue

                              type Queue struct {
                              	// contains filtered or unexported fields
                              }

                                Queue implements a multi-reader, multi-writer distributed queue.

                                func NewQueue

                                func NewQueue(client *v3.Client, keyPrefix string) *Queue

                                func (*Queue) Dequeue

                                func (q *Queue) Dequeue() (string, error)

                                  Dequeue returns Enqueue()'d elements in FIFO order. If the queue is empty, Dequeue blocks until elements are available.

                                  func (*Queue) Enqueue

                                  func (q *Queue) Enqueue(val string) error

                                  type RWMutex

                                  type RWMutex struct {
                                  	// contains filtered or unexported fields
                                  }

                                  func NewRWMutex

                                  func NewRWMutex(s *concurrency.Session, prefix string) *RWMutex

                                  func (*RWMutex) Lock

                                  func (rwm *RWMutex) Lock() error

                                  func (*RWMutex) RLock

                                  func (rwm *RWMutex) RLock() error

                                  func (*RWMutex) RUnlock

                                  func (rwm *RWMutex) RUnlock() error

                                  func (*RWMutex) Unlock

                                  func (rwm *RWMutex) Unlock() error

                                  type RemoteKV

                                  type RemoteKV struct {
                                  	// contains filtered or unexported fields
                                  }

                                    RemoteKV is a key/revision pair created by the client and stored on etcd

                                    func (*RemoteKV) Delete

                                    func (rk *RemoteKV) Delete() error

                                    func (*RemoteKV) Key

                                    func (rk *RemoteKV) Key() string

                                    func (*RemoteKV) Put

                                    func (rk *RemoteKV) Put(val string) error

                                    func (*RemoteKV) Revision

                                    func (rk *RemoteKV) Revision() int64

                                    func (*RemoteKV) Value

                                    func (rk *RemoteKV) Value() string