MINOR: add support for HAProxy 3.2 new global keywords

Add support for:

- acme.scheduler
- stress-level
- tune.epoll.mask-events
- tune.max-rules-at-once

Author: oliwer

config-parser/section-parsers.go

@@ -281,6 +281,7 @@ func (p *configParser) getGlobalParser() *Parsers { //nolint: maintidx
 	addParser(parser, &sequence, &simple.Number{Name: "tune.comp.maxlevel"})
 	addParser(parser, &sequence, &simple.Enabled{Name: "tune.disable-zero-copy-forwarding"})
 	addParser(parser, &sequence, &simple.Enabled{Name: "tune.disable-fast-forward"})
+	addParser(parser, &sequence, &simple.Word{Name: "tune.epoll.mask-events"})
 	addParser(parser, &sequence, &simple.Number{Name: "tune.events.max-events-at-once"})
 	addParser(parser, &sequence, &simple.Enabled{Name: "tune.fail-alloc"})
 	addParser(parser, &sequence, &simple.OnOff{Name: "tune.fd.edge-triggered"})
@@ -316,6 +317,7 @@ func (p *configParser) getGlobalParser() *Parsers { //nolint: maintidx
 	addParser(parser, &sequence, &simple.OnOff{Name: "tune.lua.log.loggers"})
 	addParser(parser, &sequence, &simple.AutoOnOff{Name: "tune.lua.log.stderr"})
 	addParser(parser, &sequence, &simple.Number{Name: "tune.max-checks-per-thread"})
+	addParser(parser, &sequence, &simple.Number{Name: "tune.max-rules-at-once"})
 	addParser(parser, &sequence, &simple.Number{Name: "tune.maxaccept"})
 	addParser(parser, &sequence, &simple.Number{Name: "tune.maxpollevents"})
 	addParser(parser, &sequence, &simple.Number{Name: "tune.maxrewrite"})
@@ -465,6 +467,8 @@ func (p *configParser) getGlobalParser() *Parsers { //nolint: maintidx
 	addParser(parser, &sequence, &simple.Time{Name: "force-cfg-parser-pause"})
 	addParser(parser, &sequence, &simple.Time{Name: "warn-blocked-traffic-after"})
 	addParser(parser, &sequence, &simple.Word{Name: "dns-accept-family"})
+	addParser(parser, &sequence, &simple.Word{Name: "acme.scheduler"})
+	addParser(parser, &sequence, &simple.Number{Name: "stress-level"})
 	// the ConfigSnippet must be at the end to parsers load order to ensure
 	// the overloading of any option has been declared previously
 	addParser(parser, &sequence, &parsers.ConfigSnippet{})

configuration/global.go

@@ -562,6 +562,15 @@ func parseSSLOptions(p parser.Parser) (*models.SslOptions, error) { //nolint:goc
 		options.SslEngines = sslEngines
 	}
 
+	sched, err := parseStringOption(p, "acme.scheduler")
+	if err != nil {
+		return nil, err
+	}
+	if sched != "" {
+		isEmpty = false
+		options.AcmeScheduler = sched
+	}
+
 	caBase, err := parseStringOption(p, "ca-base")
 	if err != nil {
 		return nil, err
@@ -812,6 +821,15 @@ func parseDebugOptions(p parser.Parser) (*models.DebugOptions, error) {
 		options.Anonkey = anonkey
 	}
 
+	stress, err := parseInt64POption(p, "stress-level")
+	if err != nil {
+		return nil, err
+	}
+	if stress != nil {
+		isEmpty = false
+		options.StressLevel = stress
+	}
+
 	quiet, err := parseBoolOption(p, "quiet")
 	if err != nil {
 		return nil, err
@@ -1215,6 +1233,17 @@ func parseTuneOptions(p parser.Parser) (*models.TuneOptions, error) { //nolint:g
 		options.DisableZeroCopyForwarding = boolOption
 	}
 
+	strOption, err = parseStringOption(p, "tune.epoll.mask-events")
+	if err != nil {
+		return nil, err
+	}
+	if strOption != "" {
+		if words := strings.Split(strOption, ","); len(words) > 0 && words[0] != "" {
+			isEmpty = false
+			options.EpollMaskEvents = words
+		}
+	}
+
 	intOption, err = parseInt64Option(p, "tune.events.max-events-at-once")
 	if err != nil {
 		return nil, err
@@ -1341,6 +1370,15 @@ func parseTuneOptions(p parser.Parser) (*models.TuneOptions, error) { //nolint:g
 		options.MaxChecksPerThread = intPOption
 	}
 
+	intPOption, err = parseInt64POption(p, "tune.max-rules-at-once")
+	if err != nil {
+		return nil, err
+	}
+	if intPOption != nil {
+		isEmpty = false
+		options.MaxRulesAtOnce = intPOption
+	}
+
 	intOption, err = parseInt64Option(p, "tune.maxaccept")
 	if err != nil {
 		return nil, err
@@ -2553,6 +2591,9 @@ func serializeDebugOptions(p parser.Parser, options *models.DebugOptions) error
 	if err := serializeInt64POption(p, "anonkey", options.Anonkey); err != nil {
 		return err
 	}
+	if err := serializeInt64POption(p, "stress-level", options.StressLevel); err != nil {
+		return err
+	}
 	if err := serializeBoolOption(p, "quiet", options.Quiet); err != nil {
 		return err
 	}
@@ -2714,6 +2755,10 @@ func serializeSSLOptions(p parser.Parser, options *models.SslOptions) error { //
 		return err
 	}
 
+	if err := serializeStringOption(p, "acme.scheduler", options.AcmeScheduler); err != nil {
+		return err
+	}
+
 	if err := serializeStringOption(p, "ca-base", options.CaBase); err != nil {
 		return err
 	}
@@ -3585,7 +3630,7 @@ func serializeTuneZlibOptions(p parser.Parser, options *models.TuneZlibOptions)
 	return serializeInt64Option(p, "tune.zlib.windowsize", options.Windowsize)
 }
 
-func serializeTuneOptions(p parser.Parser, options *models.TuneOptions, configOptions *options.ConfigurationOptions) error { //nolint:gocognit,gocyclo,cyclop
+func serializeTuneOptions(p parser.Parser, options *models.TuneOptions, configOptions *options.ConfigurationOptions) error { //nolint:gocognit,gocyclo,cyclop,maintidx
 	if options == nil {
 		options = &models.TuneOptions{}
 	}
@@ -3601,6 +3646,9 @@ func serializeTuneOptions(p parser.Parser, options *models.TuneOptions, configOp
 	if err := serializeBoolOption(p, "tune.disable-zero-copy-forwarding", options.DisableZeroCopyForwarding); err != nil {
 		return err
 	}
+	if err := serializeStringOption(p, "tune.epoll.mask-events", strings.Join(options.EpollMaskEvents, ",")); err != nil {
+		return err
+	}
 	if err := serializeInt64Option(p, "tune.events.max-events-at-once", options.EventsMaxEventsAtOnce); err != nil {
 		return err
 	}
@@ -3643,6 +3691,9 @@ func serializeTuneOptions(p parser.Parser, options *models.TuneOptions, configOp
 	if err := serializeInt64POption(p, "tune.max-checks-per-thread", options.MaxChecksPerThread); err != nil {
 		return err
 	}
+	if err := serializeInt64POption(p, "tune.max-rules-at-once", options.MaxRulesAtOnce); err != nil {
+		return err
+	}
 	if err := serializeInt64Option(p, "tune.maxaccept", options.Maxaccept); err != nil {
 		return err
 	}