/
local_data.go
109 lines (98 loc) · 2 KB
/
local_data.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
package core
import (
"encoding/json"
"sync"
"time"
)
// SafeLocalData ...
type SafeLocalData interface {
JSONer
JSON() string
Update(f func(data *LocalData))
Data() (data LocalData)
}
// SafeLocalData ...
type safeLocalData struct {
lock sync.RWMutex
data LocalData
}
// LocalData ...
type LocalData struct {
Initialized bool
Node NodeInfo
Nodes map[string]NodeInfo //readonly or change by update
LDs map[string]uint8 //readonly or change by update:ipfs linked data
Addrs []string
LastUpdate int64
}
// DefaultLocalData ...
func DefaultLocalData() *LocalData {
return &LocalData{
LDs: make(map[string]uint8),
LastUpdate: time.Now().Unix(),
Nodes: make(map[string]NodeInfo),
}
}
// Marshal ...
func (l *safeLocalData) Marshal() ([]byte, error) {
l.lock.RLock()
marshal, err := json.Marshal(l.data)
l.lock.RUnlock()
if err != nil {
return nil, err
}
return marshal, err
}
// Unmarshal ...
func (l *safeLocalData) Unmarshal(bytes []byte) (err error) {
l.lock.Lock()
err = json.Unmarshal(bytes, &l.data)
l.lock.Unlock()
return
}
// JSON ...
func (l *safeLocalData) JSON() string {
marshal, err := l.Marshal()
if err != nil {
return ""
}
return string(marshal)
}
// Update ...
func (l *safeLocalData) Update(f func(data *LocalData)) {
l.lock.Lock()
f(&l.data)
l.lock.Unlock()
}
// Data ...
func (l *safeLocalData) Data() (data LocalData) {
//data = LocalData{
// Initialized: false,
// Node: NodeInfo{},
// Nodes: make(map[string]NodeInfo),
// LDs: make(map[string]uint8),
// Addrs: nil,
// LastUpdate: 0,
//}
l.lock.Lock()
//data.Node = l.data.Node
//if l.data.Addrs != nil {
// copy(data.Addrs, l.data.Addrs)
//}
//for s := range l.data.Nodes {
// data.Nodes[s] = l.data.Nodes[s]
//}
//for s := range l.data.LDs {
// data.LDs[s] = l.data.LDs[s]
//}
data = l.data
l.lock.Unlock()
return
}
// Safe ...
func (l LocalData) Safe() SafeLocalData {
return &safeLocalData{
lock: sync.RWMutex{},
data: l,
}
}