/
fakestatedriver.go
128 lines (102 loc) · 2.83 KB
/
fakestatedriver.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package state
import (
"strings"
"github.com/contiv/netplugin/core"
log "github.com/Sirupsen/logrus"
)
type valueData struct {
value []byte
}
// FakeStateDriverConfig represents the configuration of the fake statedriver,
// which is an empty struct.
type FakeStateDriverConfig struct{}
// FakeStateDriver implements core.StateDriver interface for use with
// unit-tests
type FakeStateDriver struct {
TestState map[string]valueData
}
// Init the driver
func (d *FakeStateDriver) Init(config *core.Config) error {
d.TestState = make(map[string]valueData)
return nil
}
// Deinit the driver
func (d *FakeStateDriver) Deinit() {
d.TestState = nil
}
// Write value to key
func (d *FakeStateDriver) Write(key string, value []byte) error {
val := valueData{value: value}
d.TestState[key] = val
return nil
}
// Read value from key
func (d *FakeStateDriver) Read(key string) ([]byte, error) {
if val, ok := d.TestState[key]; ok {
return val.value, nil
}
return []byte{}, core.Errorf("Key not found!")
}
// ReadAll values from baseKey
func (d *FakeStateDriver) ReadAll(baseKey string) ([][]byte, error) {
values := [][]byte{}
for key, val := range d.TestState {
if strings.Contains(key, baseKey) {
values = append(values, val.value)
}
}
return values, nil
}
// WatchAll values from baseKey
func (d *FakeStateDriver) WatchAll(baseKey string, rsps chan [2][]byte) error {
return core.Errorf("not supported")
}
// ClearState clears key
func (d *FakeStateDriver) ClearState(key string) error {
if _, ok := d.TestState[key]; ok {
delete(d.TestState, key)
}
return nil
}
// ReadState unmarshals state into a core.State
func (d *FakeStateDriver) ReadState(key string, value core.State,
unmarshal func([]byte, interface{}) error) error {
encodedState, err := d.Read(key)
if err != nil {
return err
}
err = unmarshal(encodedState, value)
if err != nil {
return err
}
return nil
}
// ReadAllState reads all state from baseKey of a given type
func (d *FakeStateDriver) ReadAllState(baseKey string, sType core.State,
unmarshal func([]byte, interface{}) error) ([]core.State, error) {
return readAllStateCommon(d, baseKey, sType, unmarshal)
}
// WatchAllState reads all state from baseKey of a given type
func (d *FakeStateDriver) WatchAllState(baseKey string, sType core.State,
unmarshal func([]byte, interface{}) error, rsps chan core.WatchState) error {
return core.Errorf("not supported")
}
// WriteState writes a core.State to key.
func (d *FakeStateDriver) WriteState(key string, value core.State,
marshal func(interface{}) ([]byte, error)) error {
encodedState, err := marshal(value)
if err != nil {
return err
}
err = d.Write(key, encodedState)
if err != nil {
return err
}
return nil
}
// DumpState is a debugging tool.
func (d *FakeStateDriver) DumpState() {
for key := range d.TestState {
log.Debugf("key: %q\n", key)
}
}