-
Notifications
You must be signed in to change notification settings - Fork 199
/
dataPool.go
209 lines (184 loc) · 6.84 KB
/
dataPool.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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
package dataPool
import (
"github.com/multiversx/mx-chain-core-go/core/check"
"github.com/multiversx/mx-chain-go/dataRetriever"
"github.com/multiversx/mx-chain-go/storage"
logger "github.com/multiversx/mx-chain-logger-go"
)
var _ dataRetriever.PoolsHolder = (*dataPool)(nil)
var log = logger.GetOrCreate("dataRetriever/dataPool")
type dataPool struct {
transactions dataRetriever.ShardedDataCacherNotifier
unsignedTransactions dataRetriever.ShardedDataCacherNotifier
rewardTransactions dataRetriever.ShardedDataCacherNotifier
headers dataRetriever.HeadersPool
miniBlocks storage.Cacher
peerChangesBlocks storage.Cacher
trieNodes storage.Cacher
trieNodesChunks storage.Cacher
currBlockTxs dataRetriever.TransactionCacher
currEpochValidatorInfo dataRetriever.ValidatorInfoCacher
smartContracts storage.Cacher
peerAuthentications storage.Cacher
heartbeats storage.Cacher
validatorsInfo dataRetriever.ShardedDataCacherNotifier
}
// DataPoolArgs represents the data pool's constructor structure
type DataPoolArgs struct {
Transactions dataRetriever.ShardedDataCacherNotifier
UnsignedTransactions dataRetriever.ShardedDataCacherNotifier
RewardTransactions dataRetriever.ShardedDataCacherNotifier
Headers dataRetriever.HeadersPool
MiniBlocks storage.Cacher
PeerChangesBlocks storage.Cacher
TrieNodes storage.Cacher
TrieNodesChunks storage.Cacher
CurrentBlockTransactions dataRetriever.TransactionCacher
CurrentEpochValidatorInfo dataRetriever.ValidatorInfoCacher
SmartContracts storage.Cacher
PeerAuthentications storage.Cacher
Heartbeats storage.Cacher
ValidatorsInfo dataRetriever.ShardedDataCacherNotifier
}
// NewDataPool creates a data pools holder object
func NewDataPool(args DataPoolArgs) (*dataPool, error) {
if check.IfNil(args.Transactions) {
return nil, dataRetriever.ErrNilTxDataPool
}
if check.IfNil(args.UnsignedTransactions) {
return nil, dataRetriever.ErrNilUnsignedTransactionPool
}
if check.IfNil(args.RewardTransactions) {
return nil, dataRetriever.ErrNilRewardTransactionPool
}
if check.IfNil(args.Headers) {
return nil, dataRetriever.ErrNilHeadersDataPool
}
if check.IfNil(args.MiniBlocks) {
return nil, dataRetriever.ErrNilTxBlockDataPool
}
if check.IfNil(args.PeerChangesBlocks) {
return nil, dataRetriever.ErrNilPeerChangeBlockDataPool
}
if check.IfNil(args.CurrentBlockTransactions) {
return nil, dataRetriever.ErrNilCurrBlockTxs
}
if check.IfNil(args.CurrentEpochValidatorInfo) {
return nil, dataRetriever.ErrNilCurrentEpochValidatorInfo
}
if check.IfNil(args.TrieNodes) {
return nil, dataRetriever.ErrNilTrieNodesPool
}
if check.IfNil(args.TrieNodesChunks) {
return nil, dataRetriever.ErrNilTrieNodesChunksPool
}
if check.IfNil(args.SmartContracts) {
return nil, dataRetriever.ErrNilSmartContractsPool
}
if check.IfNil(args.PeerAuthentications) {
return nil, dataRetriever.ErrNilPeerAuthenticationPool
}
if check.IfNil(args.Heartbeats) {
return nil, dataRetriever.ErrNilHeartbeatPool
}
if check.IfNil(args.ValidatorsInfo) {
return nil, dataRetriever.ErrNilValidatorInfoPool
}
return &dataPool{
transactions: args.Transactions,
unsignedTransactions: args.UnsignedTransactions,
rewardTransactions: args.RewardTransactions,
headers: args.Headers,
miniBlocks: args.MiniBlocks,
peerChangesBlocks: args.PeerChangesBlocks,
trieNodes: args.TrieNodes,
trieNodesChunks: args.TrieNodesChunks,
currBlockTxs: args.CurrentBlockTransactions,
currEpochValidatorInfo: args.CurrentEpochValidatorInfo,
smartContracts: args.SmartContracts,
peerAuthentications: args.PeerAuthentications,
heartbeats: args.Heartbeats,
validatorsInfo: args.ValidatorsInfo,
}, nil
}
// CurrentBlockTxs returns the holder for current block transactions
func (dp *dataPool) CurrentBlockTxs() dataRetriever.TransactionCacher {
return dp.currBlockTxs
}
// CurrentEpochValidatorInfo returns the holder for current epoch validator info
func (dp *dataPool) CurrentEpochValidatorInfo() dataRetriever.ValidatorInfoCacher {
return dp.currEpochValidatorInfo
}
// Transactions returns the holder for transactions
func (dp *dataPool) Transactions() dataRetriever.ShardedDataCacherNotifier {
return dp.transactions
}
// UnsignedTransactions returns the holder for unsigned transactions (cross shard result entities)
func (dp *dataPool) UnsignedTransactions() dataRetriever.ShardedDataCacherNotifier {
return dp.unsignedTransactions
}
// RewardTransactions returns the holder for reward transactions (cross shard result entities)
func (dp *dataPool) RewardTransactions() dataRetriever.ShardedDataCacherNotifier {
return dp.rewardTransactions
}
// Headers returns the holder for headers
func (dp *dataPool) Headers() dataRetriever.HeadersPool {
return dp.headers
}
// MiniBlocks returns the holder for miniblocks
func (dp *dataPool) MiniBlocks() storage.Cacher {
return dp.miniBlocks
}
// PeerChangesBlocks returns the holder for peer changes block bodies
func (dp *dataPool) PeerChangesBlocks() storage.Cacher {
return dp.peerChangesBlocks
}
// TrieNodes returns the holder for trie nodes
func (dp *dataPool) TrieNodes() storage.Cacher {
return dp.trieNodes
}
// TrieNodesChunks returns the holder for trie nodes chunks
func (dp *dataPool) TrieNodesChunks() storage.Cacher {
return dp.trieNodesChunks
}
// SmartContracts returns the holder for smart contracts
func (dp *dataPool) SmartContracts() storage.Cacher {
return dp.smartContracts
}
// PeerAuthentications returns the holder for peer authentications
func (dp *dataPool) PeerAuthentications() storage.Cacher {
return dp.peerAuthentications
}
// Heartbeats returns the holder for heartbeats
func (dp *dataPool) Heartbeats() storage.Cacher {
return dp.heartbeats
}
// ValidatorsInfo returns the holder for validators info
func (dp *dataPool) ValidatorsInfo() dataRetriever.ShardedDataCacherNotifier {
return dp.validatorsInfo
}
// Close closes all the components
func (dp *dataPool) Close() error {
var lastError error
if !check.IfNil(dp.trieNodes) {
log.Debug("closing trie nodes data pool....")
err := dp.trieNodes.Close()
if err != nil {
log.Error("failed to close trie nodes data pool", "error", err.Error())
lastError = err
}
}
if !check.IfNil(dp.peerAuthentications) {
log.Debug("closing peer authentications data pool....")
err := dp.peerAuthentications.Close()
if err != nil {
log.Error("failed to close peer authentications data pool", "error", err.Error())
lastError = err
}
}
return lastError
}
// IsInterfaceNil returns true if there is no value under the interface
func (dp *dataPool) IsInterfaceNil() bool {
return dp == nil
}