mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
04bd8f67ad
In that commit, AtomicPutCreate takes previous = nil to Atomically create keys that don't exist. We need a create operation that is atomic to prevent races between multiple libnetworks creating the same object. Previously, we just created new KVs with an index of 0 and wrote them to the datastore. Consul accepts this behaviour and interprets index of 0 as non-existing, but other data backends do no. - Add Exists() to the KV interface. SetIndex() should also modify a KV so that it exists. - Call SetIndex() from within the GetObject() method on DataStore interface. - This ensures objects have the updated values for exists and index. - Add SetValue() to the KV interface. This allows implementers to define their own method to marshall and unmarshall (as bitseq and allocator have). - Update existing users of the DataStore (endpoint, network, bitseq, allocator, ov_network) to new interfaces. - Fix UTs.
129 lines
3.4 KiB
Go
129 lines
3.4 KiB
Go
package datastore
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/docker/libkv/store"
|
|
"github.com/docker/libnetwork/types"
|
|
)
|
|
|
|
var (
|
|
// ErrNotImplmented exported
|
|
ErrNotImplmented = errors.New("Functionality not implemented")
|
|
)
|
|
|
|
// MockData exported
|
|
type MockData struct {
|
|
Data []byte
|
|
Index uint64
|
|
}
|
|
|
|
// MockStore exported
|
|
type MockStore struct {
|
|
db map[string]*MockData
|
|
}
|
|
|
|
// NewMockStore creates a Map backed Datastore that is useful for mocking
|
|
func NewMockStore() *MockStore {
|
|
db := make(map[string]*MockData)
|
|
return &MockStore{db}
|
|
}
|
|
|
|
// Get the value at "key", returns the last modified index
|
|
// to use in conjunction to CAS calls
|
|
func (s *MockStore) Get(key string) (*store.KVPair, error) {
|
|
mData := s.db[key]
|
|
if mData == nil {
|
|
return nil, nil
|
|
}
|
|
return &store.KVPair{Value: mData.Data, LastIndex: mData.Index}, nil
|
|
|
|
}
|
|
|
|
// Put a value at "key"
|
|
func (s *MockStore) Put(key string, value []byte, options *store.WriteOptions) error {
|
|
mData := s.db[key]
|
|
if mData == nil {
|
|
mData = &MockData{value, 0}
|
|
}
|
|
mData.Index = mData.Index + 1
|
|
s.db[key] = mData
|
|
return nil
|
|
}
|
|
|
|
// Delete a value at "key"
|
|
func (s *MockStore) Delete(key string) error {
|
|
delete(s.db, key)
|
|
return nil
|
|
}
|
|
|
|
// Exists checks that the key exists inside the store
|
|
func (s *MockStore) Exists(key string) (bool, error) {
|
|
_, ok := s.db[key]
|
|
return ok, nil
|
|
}
|
|
|
|
// List gets a range of values at "directory"
|
|
func (s *MockStore) List(prefix string) ([]*store.KVPair, error) {
|
|
return nil, ErrNotImplmented
|
|
}
|
|
|
|
// DeleteTree deletes a range of values at "directory"
|
|
func (s *MockStore) DeleteTree(prefix string) error {
|
|
delete(s.db, prefix)
|
|
return nil
|
|
}
|
|
|
|
// Watch a single key for modifications
|
|
func (s *MockStore) Watch(key string, stopCh <-chan struct{}) (<-chan *store.KVPair, error) {
|
|
return nil, ErrNotImplmented
|
|
}
|
|
|
|
// WatchTree triggers a watch on a range of values at "directory"
|
|
func (s *MockStore) WatchTree(prefix string, stopCh <-chan struct{}) (<-chan []*store.KVPair, error) {
|
|
return nil, ErrNotImplmented
|
|
}
|
|
|
|
// NewLock exposed
|
|
func (s *MockStore) NewLock(key string, options *store.LockOptions) (store.Locker, error) {
|
|
return nil, ErrNotImplmented
|
|
}
|
|
|
|
// AtomicPut put a value at "key" if the key has not been
|
|
// modified in the meantime, throws an error if this is the case
|
|
func (s *MockStore) AtomicPut(key string, newValue []byte, previous *store.KVPair, options *store.WriteOptions) (bool, *store.KVPair, error) {
|
|
mData := s.db[key]
|
|
|
|
if previous == nil {
|
|
if mData != nil {
|
|
return false, nil, types.BadRequestErrorf("atomic put failed because key exists")
|
|
} // Else OK.
|
|
} else {
|
|
if mData == nil {
|
|
return false, nil, types.BadRequestErrorf("atomic put failed because key exists")
|
|
}
|
|
if mData != nil && mData.Index != previous.LastIndex {
|
|
return false, nil, types.BadRequestErrorf("atomic put failed due to mismatched Index")
|
|
} // Else OK.
|
|
}
|
|
err := s.Put(key, newValue, nil)
|
|
if err != nil {
|
|
return false, nil, err
|
|
}
|
|
return true, &store.KVPair{Key: key, Value: newValue, LastIndex: s.db[key].Index}, nil
|
|
}
|
|
|
|
// AtomicDelete deletes a value at "key" if the key has not
|
|
// been modified in the meantime, throws an error if this is the case
|
|
func (s *MockStore) AtomicDelete(key string, previous *store.KVPair) (bool, error) {
|
|
mData := s.db[key]
|
|
if mData != nil && mData.Index != previous.LastIndex {
|
|
return false, types.BadRequestErrorf("atomic delete failed due to mismatched Index")
|
|
}
|
|
return true, s.Delete(key)
|
|
}
|
|
|
|
// Close closes the client connection
|
|
func (s *MockStore) Close() {
|
|
return
|
|
}
|