-
Notifications
You must be signed in to change notification settings - Fork 931
/
config.go
287 lines (269 loc) · 12.3 KB
/
config.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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
/*
Package featureconfig defines which features are enabled for runtime
in order to selectively enable certain features to maintain a stable runtime.
The process for implementing new features using this package is as follows:
1. Add a new CMD flag in flags.go, and place it in the proper list(s) var for its client.
2. Add a condition for the flag in the proper Configure function(s) below.
3. Place any "new" behavior in the `if flagEnabled` statement.
4. Place any "previous" behavior in the `else` statement.
5. Ensure any tests using the new feature fail if the flag isn't enabled.
5a. Use the following to enable your flag for tests:
cfg := &featureconfig.Flags{
VerifyAttestationSigs: true,
}
resetCfg := featureconfig.InitWithReset(cfg)
defer resetCfg()
6. Add the string for the flags that should be running within E2E to E2EValidatorFlags
and E2EBeaconChainFlags.
*/
package featureconfig
import (
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/sirupsen/logrus"
"gopkg.in/urfave/cli.v2"
)
var log = logrus.WithField("prefix", "flags")
// Flags is a struct to represent which features the client will perform on runtime.
type Flags struct {
MinimalConfig bool // MinimalConfig as defined in the spec.
WriteSSZStateTransitions bool // WriteSSZStateTransitions to tmp directory.
InitSyncNoVerify bool // InitSyncNoVerify when initial syncing w/o verifying block's contents.
DisableDynamicCommitteeSubnets bool // Disables dynamic attestation committee subnets via p2p.
SkipBLSVerify bool // Skips BLS verification across the runtime.
EnableBackupWebhook bool // EnableBackupWebhook to allow database backups to trigger from monitoring port /db/backup.
PruneEpochBoundaryStates bool // PruneEpochBoundaryStates prunes the epoch boundary state before last finalized check point.
EnableSnappyDBCompression bool // EnableSnappyDBCompression in the database.
ProtectProposer bool // ProtectProposer prevents the validator client from signing any proposals that would be considered a slashable offense.
ProtectAttester bool // ProtectAttester prevents the validator client from signing any attestations that would be considered a slashable offense.
SlasherProtection bool // SlasherProtection protects validator fron sending over a slashable offense over the network using external slasher.
DisableStrictAttestationPubsubVerification bool // DisableStrictAttestationPubsubVerification will disabling strict signature verification in pubsub.
DisableUpdateHeadPerAttestation bool // DisableUpdateHeadPerAttestation will disabling update head on per attestation basis.
EnableDomainDataCache bool // EnableDomainDataCache caches validator calls to DomainData per epoch.
EnableStateGenSigVerify bool // EnableStateGenSigVerify verifies proposer and randao signatures during state gen.
CheckHeadState bool // CheckHeadState checks the current headstate before retrieving the desired state from the db.
EnableNoise bool // EnableNoise enables the beacon node to use NOISE instead of SECIO when performing a handshake with another peer.
DontPruneStateStartUp bool // DontPruneStateStartUp disables pruning state upon beacon node start up.
NewStateMgmt bool // NewStateMgmt enables the new state mgmt service.
EnableFieldTrie bool // EnableFieldTrie enables the state from using field specific tries when computing the root.
NoInitSyncBatchSaveBlocks bool // NoInitSyncBatchSaveBlocks disables batch save blocks mode during initial syncing.
EnableStateRefCopy bool // EnableStateRefCopy copies the references to objects instead of the objects themselves when copying state fields.
WaitForSynced bool // WaitForSynced uses WaitForSynced in validator startup to ensure it can communicate with the beacon node as soon as possible.
SkipRegenHistoricalStates bool // SkipRegenHistoricalState skips regenerating historical states from genesis to last finalized. This enables a quick switch over to using new-state-mgmt.
EnableInitSyncWeightedRoundRobin bool // EnableInitSyncWeightedRoundRobin enables weighted round robin fetching optimization in initial syncing.
// DisableForkChoice disables using LMD-GHOST fork choice to update
// the head of the chain based on attestations and instead accepts any valid received block
// as the chain head. UNSAFE, use with caution.
DisableForkChoice bool
// BroadcastSlashings enables p2p broadcasting of proposer or attester slashing.
BroadcastSlashings bool
DisableHistoricalDetection bool // DisableHistoricalDetection disables historical attestation detection and performs detection on the chain head immediately.
DisableLookback bool // DisableLookback updates slasher to not use the lookback and update validator histories until epoch 0.
// Cache toggles.
EnableSSZCache bool // EnableSSZCache see https://github.com/prysmaticlabs/prysm/pull/4558.
EnableEth1DataVoteCache bool // EnableEth1DataVoteCache; see https://github.com/prysmaticlabs/prysm/issues/3106.
EnableSlasherConnection bool // EnableSlasher enable retrieval of slashing events from a slasher instance.
EnableBlockTreeCache bool // EnableBlockTreeCache enable fork choice service to maintain latest filtered block tree.
KafkaBootstrapServers string // KafkaBootstrapServers to find kafka servers to stream blocks, attestations, etc.
CustomGenesisDelay uint64 // CustomGenesisDelay signals how long of a delay to set to start the chain.
}
var featureConfig *Flags
// Get retrieves feature config.
func Get() *Flags {
if featureConfig == nil {
return &Flags{}
}
return featureConfig
}
// Init sets the global config equal to the config that is passed in.
func Init(c *Flags) {
featureConfig = c
}
// InitWithReset sets the global config and returns function that is used to reset configuration.
func InitWithReset(c *Flags) func() {
resetFunc := func() {
Init(&Flags{})
}
Init(c)
return resetFunc
}
// ConfigureBeaconChain sets the global config based
// on what flags are enabled for the beacon-chain client.
func ConfigureBeaconChain(ctx *cli.Context) {
complainOnDeprecatedFlags(ctx)
cfg := &Flags{}
cfg = configureConfig(ctx, cfg)
if ctx.Bool(devModeFlag.Name) {
enableDevModeFlags(ctx)
}
delay := params.BeaconConfig().MinGenesisDelay
if ctx.IsSet(customGenesisDelayFlag.Name) {
delay = ctx.Uint64(customGenesisDelayFlag.Name)
log.Warnf("Starting ETH2 with genesis delay of %d seconds", delay)
}
cfg.CustomGenesisDelay = delay
if ctx.Bool(writeSSZStateTransitionsFlag.Name) {
log.Warn("Writing SSZ states and blocks after state transitions")
cfg.WriteSSZStateTransitions = true
}
if ctx.Bool(disableForkChoiceUnsafeFlag.Name) {
log.Warn("UNSAFE: Disabled fork choice for updating chain head")
cfg.DisableForkChoice = true
}
if ctx.Bool(disableDynamicCommitteeSubnets.Name) {
log.Warn("Disabled dynamic attestation committee subnets")
cfg.DisableDynamicCommitteeSubnets = true
}
cfg.EnableSSZCache = true
if ctx.Bool(disableSSZCache.Name) {
log.Warn("Disabled ssz cache")
cfg.EnableSSZCache = false
}
if ctx.Bool(initSyncVerifyEverythingFlag.Name) {
log.Warn("Initial syncing with verifying all block's content signatures.")
cfg.InitSyncNoVerify = false
} else {
cfg.InitSyncNoVerify = true
}
if ctx.Bool(skipBLSVerifyFlag.Name) {
log.Warn("UNSAFE: Skipping BLS verification at runtime")
cfg.SkipBLSVerify = true
}
if ctx.Bool(enableBackupWebhookFlag.Name) {
log.Warn("Allowing database backups to be triggered from HTTP webhook.")
cfg.EnableBackupWebhook = true
}
if ctx.String(kafkaBootstrapServersFlag.Name) != "" {
log.Warn("Enabling experimental kafka streaming.")
cfg.KafkaBootstrapServers = ctx.String(kafkaBootstrapServersFlag.Name)
}
if ctx.Bool(enableSlasherFlag.Name) {
log.Warn("Enable slasher connection.")
cfg.EnableSlasherConnection = true
}
if ctx.Bool(cacheFilteredBlockTreeFlag.Name) {
log.Warn("Enabled filtered block tree cache for fork choice.")
cfg.EnableBlockTreeCache = true
}
if ctx.Bool(disableStrictAttestationPubsubVerificationFlag.Name) {
log.Warn("Disabled strict attestation signature verification in pubsub")
cfg.DisableStrictAttestationPubsubVerification = true
}
if ctx.Bool(disableUpdateHeadPerAttestation.Name) {
log.Warn("Disabled update head on per attestation basis")
cfg.DisableUpdateHeadPerAttestation = true
}
if ctx.Bool(enableStateGenSigVerify.Name) {
log.Warn("Enabling sig verify for state gen")
cfg.EnableStateGenSigVerify = true
}
if ctx.Bool(checkHeadState.Name) {
log.Warn("Enabling check head state for chainservice")
cfg.CheckHeadState = true
}
if ctx.Bool(enableNoiseHandshake.Name) {
log.Warn("Enabling noise handshake for peer")
cfg.EnableNoise = true
}
if ctx.Bool(dontPruneStateStartUp.Name) {
log.Warn("Not enabling state pruning upon start up")
cfg.DontPruneStateStartUp = true
}
if ctx.Bool(enableNewStateMgmt.Name) {
log.Warn("Enabling state management service")
cfg.NewStateMgmt = true
}
if ctx.Bool(enableFieldTrie.Name) {
log.Warn("Enabling state field trie")
cfg.EnableFieldTrie = true
}
if ctx.Bool(disableInitSyncBatchSaveBlocks.Name) {
log.Warn("Disabling init sync batch save blocks mode")
cfg.NoInitSyncBatchSaveBlocks = true
}
if ctx.Bool(enableStateRefCopy.Name) {
log.Warn("Enabling state reference copy")
cfg.EnableStateRefCopy = true
}
if ctx.Bool(broadcastSlashingFlag.Name) {
log.Warn("Enabling broadcast slashing to p2p network")
cfg.BroadcastSlashings = true
}
if ctx.Bool(skipRegenHistoricalStates.Name) {
log.Warn("Enabling skipping of historical states regen")
cfg.SkipRegenHistoricalStates = true
}
if ctx.Bool(enableInitSyncWeightedRoundRobin.Name) {
log.Warn("Enabling weighted round robin in initial syncing")
cfg.EnableInitSyncWeightedRoundRobin = true
}
Init(cfg)
}
// ConfigureSlasher sets the global config based
// on what flags are enabled for the slasher client.
func ConfigureSlasher(ctx *cli.Context) {
complainOnDeprecatedFlags(ctx)
cfg := &Flags{}
cfg = configureConfig(ctx, cfg)
if ctx.Bool(disableHistoricalDetectionFlag.Name) {
log.Warn("Disabling historical attestation detection")
cfg.DisableHistoricalDetection = true
}
if ctx.Bool(disableLookbackFlag.Name) {
log.Warn("Disabling slasher lookback")
cfg.DisableLookback = true
}
Init(cfg)
}
// ConfigureValidator sets the global config based
// on what flags are enabled for the validator client.
func ConfigureValidator(ctx *cli.Context) {
complainOnDeprecatedFlags(ctx)
cfg := &Flags{}
cfg = configureConfig(ctx, cfg)
if ctx.Bool(enableProtectProposerFlag.Name) {
log.Warn("Enabled validator proposal slashing protection.")
cfg.ProtectProposer = true
}
if ctx.Bool(enableProtectAttesterFlag.Name) {
log.Warn("Enabled validator attestation slashing protection.")
cfg.ProtectAttester = true
}
if ctx.Bool(enableExternalSlasherProtectionFlag.Name) {
log.Warn("Enabled validator attestation and block slashing protection using an external slasher.")
cfg.SlasherProtection = true
}
cfg.EnableDomainDataCache = true
if ctx.Bool(disableDomainDataCacheFlag.Name) {
log.Warn("Disabled domain data cache.")
cfg.EnableDomainDataCache = false
}
Init(cfg)
}
// enableDevModeFlags switches development mode features on.
func enableDevModeFlags(ctx *cli.Context) {
log.Warn("Enabling development mode flags")
for _, f := range devModeFlags {
if !ctx.IsSet(f.Names()[0]) {
if err := ctx.Set(f.Names()[0], "true"); err != nil {
log.WithError(err).Debug("Error enabling development mode flag")
}
}
}
}
func complainOnDeprecatedFlags(ctx *cli.Context) {
for _, f := range deprecatedFlags {
if ctx.IsSet(f.Names()[0]) {
log.Errorf("%s is deprecated and has no effect. Do not use this flag, it will be deleted soon.", f.Names()[0])
}
}
}
func configureConfig(ctx *cli.Context, cfg *Flags) *Flags {
if ctx.Bool(minimalConfigFlag.Name) {
log.Warn("Using minimal config")
cfg.MinimalConfig = true
params.UseMinimalConfig()
} else {
log.Warn("Using default mainnet config")
}
return cfg
}