-
Notifications
You must be signed in to change notification settings - Fork 15
/
file.go
139 lines (122 loc) · 2.81 KB
/
file.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
129
130
131
132
133
134
135
136
137
138
139
package storage
import (
"fmt"
"sync"
"github.com/harness/ff-golang-server-sdk/logger"
jsoniter "github.com/json-iterator/go"
"os"
"path/filepath"
"time"
)
// FileStore object is simple JSON file representation
type FileStore struct {
project string
path string
mu sync.Mutex
data map[string]interface{}
lastPersisted time.Time
logger logger.Logger
}
// NewFileStore creates a new file store instance
func NewFileStore(project string, path string, logger logger.Logger) *FileStore {
return &FileStore{
project: project,
path: filepath.Join(path, fmt.Sprintf("harness-ffm-v1-%s.json", project)),
data: make(map[string]interface{}),
logger: logger,
}
}
var json = jsoniter.ConfigCompatibleWithStandardLibrary
// Reset data with custom value, if persist is true save it to the store
func (ds *FileStore) Reset(data map[string]interface{}, persist bool) error {
ds.data = data
if persist {
return ds.Persist()
}
return nil
}
// Load data from the store
func (ds *FileStore) Load() error {
file, err := os.Open(ds.path)
if err != nil {
return err
}
defer func() {
if file != nil {
if err := file.Close(); err != nil {
ds.logger.Errorf("error closing file, err: %v", err)
}
}
}()
ds.mu.Lock()
defer ds.mu.Unlock()
dec := json.NewDecoder(file)
if err := dec.Decode(&ds.data); err != nil {
return err
}
return nil
}
// Persist data to the store
func (ds *FileStore) Persist() error {
file, err := os.Create(ds.path)
if err != nil {
return err
}
defer func() {
if file != nil {
if err := file.Close(); err != nil {
ds.logger.Errorf("error closing file, err: %v", err)
}
}
}()
enc := json.NewEncoder(file)
ds.mu.Lock()
defer ds.mu.Unlock()
if err := enc.Encode(ds.data); err != nil {
return err
}
ds.lastPersisted = ds.getTime()
return nil
}
func (ds *FileStore) getTime() time.Time {
return time.Now()
}
// Get value with the specified key
func (ds *FileStore) Get(key string) (interface{}, bool) {
ds.mu.Lock()
val, ok := ds.data[key]
ds.mu.Unlock()
return val, ok
}
// List all values
func (ds *FileStore) List() []interface{} {
var values []interface{}
ds.mu.Lock()
for _, val := range ds.data {
values = append(values, val)
}
ds.mu.Unlock()
return values
}
// Set new key and value
func (ds *FileStore) Set(key string, value interface{}) error {
ds.mu.Lock()
ds.data[key] = value
ds.mu.Unlock()
return nil
}
// Remove object from data store identified by key parameter
func (ds *FileStore) Remove(key string) error {
ds.mu.Lock()
delete(ds.data, key)
ds.mu.Unlock()
return nil
}
// PersistedAt returns when it was last recorded
func (ds *FileStore) PersistedAt() time.Time {
return ds.lastPersisted
}
// SetLogger set logger
func (ds *FileStore) SetLogger(logger logger.Logger) {
ds.logger = logger
}