Removed stateless rate limitter and turned it to a function. Updated usages. Renamed config structures

Author: durkmurder

cmd/collection/main.go

@@ -111,7 +111,7 @@ func main() {
 		txRatelimits                        float64
 		txBurstlimits                       int
 		txRatelimitPayers                   string
-		bySealingLagRateLimiterConfigGetter module.BySealingLagRateLimiterConfigGetter
+		bySealingLagRateLimiterConfigGetter module.ReadonlySealingLagRateLimiterConfig
 	)
 	var deprecatedFlagBlockRateDelay time.Duration
 

engine/collection/epochmgr/factories/builder.go

@@ -24,7 +24,7 @@ type BuilderFactory struct {
 	opts             []builder.Opt
 	metrics          module.CollectionMetrics
 	pusher           collection.GuaranteedCollectionPublisher // engine for pushing finalized collection to consensus committee
-	configGetter     module.BySealingLagRateLimiterConfigGetter
+	configGetter     module.ReadonlySealingLagRateLimiterConfig
 	log              zerolog.Logger
 }
 
@@ -36,7 +36,7 @@ func NewBuilderFactory(
 	metrics module.CollectionMetrics,
 	pusher collection.GuaranteedCollectionPublisher,
 	log zerolog.Logger,
-	configGetter module.BySealingLagRateLimiterConfigGetter,
+	configGetter module.ReadonlySealingLagRateLimiterConfig,
 	opts ...builder.Opt,
 ) (*BuilderFactory, error) {
 

module/builder/collection/builder.go

@@ -41,7 +41,7 @@ type Builder struct {
 	transactions               mempool.Transactions
 	tracer                     module.Tracer
 	config                     Config
-	bySealingRateLimiterConfig module.BySealingLagRateLimiterConfigGetter
+	bySealingRateLimiterConfig module.ReadonlySealingLagRateLimiterConfig
 	log                        zerolog.Logger
 	clusterEpoch               uint64 // the operating epoch for this cluster
 	// cache of values about the operating epoch which never change
@@ -61,7 +61,7 @@ func NewBuilder(
 	transactions mempool.Transactions,
 	log zerolog.Logger,
 	epochCounter uint64,
-	bySealingRateLimiterConfig module.BySealingLagRateLimiterConfigGetter,
+	bySealingRateLimiterConfig module.ReadonlySealingLagRateLimiterConfig,
 	opts ...Opt,
 ) (*Builder, error) {
 	b := Builder{
@@ -236,7 +236,8 @@ func (b *Builder) getBlockBuildContext(parentID flow.Identifier) (*blockBuildCon
 	ctx.config = b.config
 	ctx.parentID = parentID
 	ctx.lookup = newTransactionLookup()
-	bySealingLagRateLimiter, err := NewBySealingLagRateLimiter(
+	var err error
+	ctx.config.MaxCollectionSize, err = GetMaxCollectionSizeForSealingLag(
 		b.protoState,
 		b.bySealingRateLimiterConfig.MinSealingLag(),
 		b.bySealingRateLimiterConfig.MaxSealingLag(),
@@ -247,7 +248,6 @@ func (b *Builder) getBlockBuildContext(parentID flow.Identifier) (*blockBuildCon
 	if err != nil {
 		return nil, fmt.Errorf("could not create by sealing lag rate limiter: %w", err)
 	}
-	ctx.config.MaxCollectionSize = bySealingLagRateLimiter.MaxCollectionSize()
 	b.metrics.CollectionMaxSize(ctx.config.MaxCollectionSize)
 
 	ctx.parent, err = b.clusterHeaders.ByBlockID(parentID)

module/builder/collection/rate_limiter.go

@@ -126,54 +126,30 @@ type BySealingLagRateLimiter struct {
 	currentCollectionSize uint
 }
 
-// NewBySealingLagRateLimiter creates a new BySealingLagRateLimiter instance.
-// No errors are expected during normal operations.
-func NewBySealingLagRateLimiter(
+func GetMaxCollectionSizeForSealingLag(
 	state protocol.State,
 	minSealingLag uint,
 	maxSealingLag uint,
 	halvingInterval uint,
 	minCollectionSize uint,
-	maxCollectionSize uint,
-) (*BySealingLagRateLimiter, error) {
-	limiter := &BySealingLagRateLimiter{
-		state:             state,
-		minSealingLag:     minSealingLag,
-		maxSealingLag:     maxSealingLag,
-		halvingInterval:   halvingInterval,
-		minCollectionSize: minCollectionSize,
-		maxCollectionSize: maxCollectionSize,
-	}
-	err := limiter.update()
-	if err != nil {
-		return nil, err
-	}
-	return limiter, nil
-}
+	maxCollectionSize uint) (uint, error) {
 
-// update updates the current collection size based on the sealing lag.
-func (limiter *BySealingLagRateLimiter) update() error {
-	lastFinalized, err := limiter.state.Final().Head()
+	lastFinalized, err := state.Final().Head()
 	if err != nil {
-		return err
+		return 0, err
 	}
-	lastSealed, err := limiter.state.Sealed().Head()
+	lastSealed, err := state.Sealed().Head()
 	if err != nil {
-		return err
+		return 0, err
 	}
 	sealingLag := uint(lastFinalized.Height - lastSealed.Height)
-	limiter.currentCollectionSize = StepHalving(
-		[2]uint{limiter.minSealingLag, limiter.maxSealingLag},         // [minSealingLag, maxSealingLag] is the range of input values where the halving is applied
-		[2]uint{limiter.minCollectionSize, limiter.maxCollectionSize}, // [minCollectionSize, maxCollectionSize] is the range of collection sizes that halving function outputs
-		sealingLag,              // the current sealing lag
-		limiter.halvingInterval, // interval in blocks in which the halving is applied
+	collectionSize := StepHalving(
+		[2]uint{minSealingLag, maxSealingLag},         // [minSealingLag, maxSealingLag] is the range of input values where the halving is applied
+		[2]uint{minCollectionSize, maxCollectionSize}, // [minCollectionSize, maxCollectionSize] is the range of collection sizes that halving function outputs
+		sealingLag,      // the current sealing lag
+		halvingInterval, // interval in blocks in which the halving is applied
 	)
-	return nil
-}
-
-// MaxCollectionSize returns the maximum size of a collection that this rate limiter allows.
-func (limiter *BySealingLagRateLimiter) MaxCollectionSize() uint {
-	return limiter.currentCollectionSize
+	return collectionSize, nil
 }
 
 // StepHalving applies a step halving algorithm to determine the maximum collection size based on the sealing lag.

…ealing_lag_rate_limiter_config_getter.go …donly_sealing_lag_rate_limiter_config.gomodule/mock/by_sealing_lag_rate_limiter_config_getter.go renamed to module/mock/readonly_sealing_lag_rate_limiter_config.go module/mock/by_sealing_lag_rate_limiter_config_getter.go renamed to module/mock/readonly_sealing_lag_rate_limiter_config.go

@@ -29,15 +29,15 @@ type SealingConfigsSetter interface {
 	SetRequiredApprovalsForSealingConstruction(newVal uint) error
 }
 
-// BySealingLagRateLimiterConfigGetter is an interface for the actual updatable configs module.
+// ReadonlySealingLagRateLimiterConfig is an interface for the actual updatable configs module.
 // but only exposes its getter methods to return the config values without exposing
 // its setter methods.
-// BySealingLagRateLimiterConfigGetter contains several configs:
+// ReadonlySealingLagRateLimiterConfig contains several configs:
 // - MinSealingLag (updatable)
 // - MaxSealingLag (updatable)
 // - HalvingInterval (updatable)
 // - MinCollectionSize (updatable)
-type BySealingLagRateLimiterConfigGetter interface {
+type ReadonlySealingLagRateLimiterConfig interface {
 	// MinSealingLag is the minimum sealing lag that the rate limiter will allow.
 	MinSealingLag() uint
 	// MaxSealingLag is the maximum sealing lag that the rate limiter will allow.
@@ -48,9 +48,9 @@ type BySealingLagRateLimiterConfigGetter interface {
 	MinCollectionSize() uint
 }
 
-// BySealingLagRateLimiterConfigSetter is an interface that allows the caller to update updatable configs
-type BySealingLagRateLimiterConfigSetter interface {
-	BySealingLagRateLimiterConfigGetter
+// SealingLagRateLimiterConfig is an interface that allows the caller to update updatable configs
+type SealingLagRateLimiterConfig interface {
+	ReadonlySealingLagRateLimiterConfig
 	// SetMinSealingLag takes a new config value and updates the config
 	// if the new value is valid.
 	// Returns ValidationError if the new value results in an invalid config.

…ealing_lag_rate_limiter_config_setter.go …/mock/sealing_lag_rate_limiter_config.gomodule/mock/by_sealing_lag_rate_limiter_config_setter.go renamed to module/mock/sealing_lag_rate_limiter_config.go module/mock/by_sealing_lag_rate_limiter_config_setter.go renamed to module/mock/sealing_lag_rate_limiter_config.go

@@ -14,11 +14,11 @@ type bySealingLagRateLimiterConfigs struct {
 	minCollectionSize *atomic.Uint32
 }
 
-var _ module.BySealingLagRateLimiterConfigSetter = (*bySealingLagRateLimiterConfigs)(nil)
+var _ module.SealingLagRateLimiterConfig = (*bySealingLagRateLimiterConfigs)(nil)
 
 // DefaultBySealingLagRateLimiterConfigs returns a default config for collection throttling.
 // It performs binary throttling once the sealing lag reaches max sealing lag.
-func DefaultBySealingLagRateLimiterConfigs() module.BySealingLagRateLimiterConfigSetter {
+func DefaultBySealingLagRateLimiterConfigs() module.SealingLagRateLimiterConfig {
 	// default config results in binary throttling once the sealing lag reaches max sealing lag, before that no throttling
 	// is being applied. The 600 blocks is chosen as it is roughly 5 minutes.
 	// 2 blocks / second * 60 seconds * 5 minutes = 600 blocks