physical

Documentation

Index

• Constants
• func ExerciseBackend(t *testing.T, b Backend)
• func ExerciseBackend_ListPrefix(t *testing.T, b Backend)
• func ExerciseEventuallyConsistentBackend(t *testing.T, b Backend, d Delays)
• func ExerciseEventuallyConsistentBackend_ListPrefix(t *testing.T, b Backend, d Delays)
• func ExerciseHABackend(t *testing.T, b HABackend, b2 HABackend)
• func ExerciseTransactionalBackend(t *testing.T, b Backend)
• func GenericTransactionHandler(t PseudoTransactional, txns []TxnEntry) (retErr error)
• func Prefixes(s string) []string
• type ActiveFunction
• type Backend
• type Cache
  • func NewCache(b Backend, size int, logger log.Logger) *Cache
  • func (c *Cache) Delete(key string) error
  • func (c *Cache) Get(key string) (*Entry, error)
  • func (c *Cache) List(prefix string) ([]string, error)
  • func (c *Cache) Purge()
  • func (c *Cache) Put(entry *Entry) error
• type Delays
• type Entry
• type Factory
• type HABackend
• type Lock
• type Operation
• type PermitPool
  • func NewPermitPool(permits int) *PermitPool
  • func (c *PermitPool) Acquire()
  • func (c *PermitPool) Release()
• type PseudoTransactional
• type Purgable
• type RedirectDetect
• type SealedFunction
• type ServiceDiscovery
• type ShutdownChannel
• type Transactional
• type TransactionalCache
  • func NewTransactionalCache(b Backend, size int, logger log.Logger) *TransactionalCache
  • func (c *TransactionalCache) Transaction(txns []TxnEntry) error
• type TxnEntry
  • func SetupTestingTransactions(t *testing.T, b Backend) []TxnEntry
• type View
  • func NewView(backend Backend, prefix string) *View
  • func (v *View) Delete(key string) error
  • func (v *View) Get(key string) (*Entry, error)
  • func (v *View) List(prefix string) ([]string, error)
  • func (v *View) Put(entry *Entry) error

Constants

const (
	DeleteOperation Operation = "delete"
	GetOperation              = "get"
	ListOperation             = "list"
	PutOperation              = "put"
)

const (
	// DefaultCacheSize is used if no cache size is specified for NewCache
	DefaultCacheSize = 32 * 1024
)

const DefaultParallelOperations = 128

Functions

func ExerciseBackend

func ExerciseBackend(t *testing.T, b Backend)

func ExerciseBackend_ListPrefix

func ExerciseBackend_ListPrefix(t *testing.T, b Backend)

func ExerciseEventuallyConsistentBackend

func ExerciseEventuallyConsistentBackend(t *testing.T, b Backend, d Delays)

func ExerciseEventuallyConsistentBackend_ListPrefix

func ExerciseEventuallyConsistentBackend_ListPrefix(t *testing.T, b Backend, d Delays)

func ExerciseHABackend

func ExerciseHABackend(t *testing.T, b HABackend, b2 HABackend)

func ExerciseTransactionalBackend

func ExerciseTransactionalBackend(t *testing.T, b Backend)

func GenericTransactionHandler

func GenericTransactionHandler(t PseudoTransactional, txns []TxnEntry) (retErr error)

Implements the transaction interface

func Prefixes

func Prefixes(s string) []string

Prefixes is a shared helper function returns all parent 'folders' for a given vault key. e.g. for 'foo/bar/baz', it returns ['foo', 'foo/bar']

Types

type ActiveFunction

type ActiveFunction func() bool

Callback signatures for RunServiceDiscovery

type Backend

type Backend interface {
	// Put is used to insert or update an entry
	Put(entry *Entry) error

	// Get is used to fetch an entry
	Get(key string) (*Entry, error)

	// Delete is used to permanently delete an entry
	Delete(key string) error

	// List is used ot list all the keys under a given
	// prefix, up to the next prefix.
	List(prefix string) ([]string, error)
}

Backend is the interface required for a physical backend. A physical backend is used to durably store data outside of Vault. As such, it is completely untrusted, and is only accessed via a security barrier. The backends must represent keys in a hierarchical manner. All methods are expected to be thread safe.

type Cache

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

Cache is used to wrap an underlying physical backend and provide an LRU cache layer on top. Most of the reads done by Vault are for policy objects so there is a large read reduction by using a simple write-through cache.

func NewCache

func NewCache(b Backend, size int, logger log.Logger) *Cache

NewCache returns a physical cache of the given size. If no size is provided, the default size is used.

func (*Cache) Delete

func (c *Cache) Delete(key string) error

func (*Cache) Get

func (c *Cache) Get(key string) (*Entry, error)

func (*Cache) List

func (c *Cache) List(prefix string) ([]string, error)

func (*Cache) Purge

func (c *Cache) Purge()

Purge is used to clear the cache

func (*Cache) Put

func (c *Cache) Put(entry *Entry) error

type Delays

type Delays struct {
	BeforeGet  time.Duration
	BeforeList time.Duration
}

type Entry

type Entry struct {
	Key   string
	Value []byte
}

Entry is used to represent data stored by the physical backend

type Factory

type Factory func(config map[string]string, logger log.Logger) (Backend, error)

Factory is the factory function to create a physical backend.

type HABackend

type HABackend interface {
	// LockWith is used for mutual exclusion based on the given key.
	LockWith(key, value string) (Lock, error)

	// Whether or not HA functionality is enabled
	HAEnabled() bool
}

HABackend is an extensions to the standard physical backend to support high-availability. Vault only expects to use mutual exclusion to allow multiple instances to act as a hot standby for a leader that services all requests.

type Lock

type Lock interface {
	// Lock is used to acquire the given lock
	// The stopCh is optional and if closed should interrupt the lock
	// acquisition attempt. The return struct should be closed when
	// leadership is lost.
	Lock(stopCh <-chan struct{}) (<-chan struct{}, error)

	// Unlock is used to release the lock
	Unlock() error

	// Returns the value of the lock and if it is held
	Value() (bool, string, error)
}

type Operation

type Operation string

The operation type

type PermitPool

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

PermitPool is used to limit maximum outstanding requests

func NewPermitPool

func NewPermitPool(permits int) *PermitPool

NewPermitPool returns a new permit pool with the provided number of permits

func (*PermitPool) Acquire

func (c *PermitPool) Acquire()

Acquire returns when a permit has been acquired

func (*PermitPool) Release

func (c *PermitPool) Release()

Release returns a permit to the pool

type PseudoTransactional

type PseudoTransactional interface {
	// An internal function should do no locking or permit pool acquisition.
	// Depending on the backend and if it natively supports transactions, these
	// may simply chain to the normal backend functions.
	GetInternal(string) (*Entry, error)
	PutInternal(*Entry) error
	DeleteInternal(string) error
}

type Purgable

type Purgable interface {
	Purge()
}

Purgable is an optional interface for backends that support purging of their caches.

type RedirectDetect

type RedirectDetect interface {
	// DetectHostAddr is used to detect the host address
	DetectHostAddr() (string, error)
}

RedirectDetect is an optional interface that an HABackend can implement. If they do, a redirect address can be automatically detected.

type SealedFunction

type SealedFunction func() bool

type ServiceDiscovery

type ServiceDiscovery interface {
	// NotifyActiveStateChange is used by Core to notify a backend
	// capable of ServiceDiscovery that this Vault instance has changed
	// its status to active or standby.
	NotifyActiveStateChange() error

	// NotifySealedStateChange is used by Core to notify a backend
	// capable of ServiceDiscovery that Vault has changed its Sealed
	// status to sealed or unsealed.
	NotifySealedStateChange() error

	// Run executes any background service discovery tasks until the
	// shutdown channel is closed.
	RunServiceDiscovery(waitGroup *sync.WaitGroup, shutdownCh ShutdownChannel, redirectAddr string, activeFunc ActiveFunction, sealedFunc SealedFunction) error
}

ServiceDiscovery is an optional interface that an HABackend can implement. If they do, the state of a backend is advertised to the service discovery network.

type ShutdownChannel

type ShutdownChannel chan struct{}

ShutdownSignal

type Transactional

type Transactional interface {
	// The function to run a transaction
	Transaction([]TxnEntry) error
}

Transactional is an optional interface for backends that support doing transactional updates of multiple keys. This is required for some features such as replication.

type TransactionalCache

type TransactionalCache struct {
	*Cache
	Transactional
}

TransactionalCache is a Cache that wraps the physical that is transactional

func NewTransactionalCache

func NewTransactionalCache(b Backend, size int, logger log.Logger) *TransactionalCache

func (*TransactionalCache) Transaction

func (c *TransactionalCache) Transaction(txns []TxnEntry) error

type TxnEntry

type TxnEntry struct {
	Operation Operation
	Entry     *Entry
}

TxnEntry is an operation that takes atomically as part of a transactional update. Only supported by Transactional backends.

func SetupTestingTransactions

func SetupTestingTransactions(t *testing.T, b Backend) []TxnEntry

type View

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

View represents a prefixed view of a physical backend

func NewView

func NewView(backend Backend, prefix string) *View

NewView takes an underlying physical backend and returns a view of it that can only operate with the given prefix.

func (*View) Delete

func (v *View) Delete(key string) error

Delete the entry from the prefix view

func (*View) Get

func (v *View) Get(key string) (*Entry, error)

Get the key of the prefixed view

func (*View) List

func (v *View) List(prefix string) ([]string, error)

List the contents of the prefixed view

func (*View) Put

func (v *View) Put(entry *Entry) error

Put the entry into the prefix view