XHTTP XMUX: cMaxLifetimeMs -> hMaxReusableSecs, Refactor default …

…values

"xmux": {
    "maxConcurrency": "16-32",
    "maxConnections": 0,
    "cMaxReuseTimes": 0,
    "hMaxRequestTimes": "600-900",
    "hMaxReusableSecs": "1800-3000",
    "hKeepAlivePeriod": 0
}

Fixes #4113 (reply in thread)

infra/conf/transport_internet.go

@@ -240,8 +240,8 @@ type XmuxConfig struct {
 	MaxConcurrency   Int32Range `json:"maxConcurrency"`
 	MaxConnections   Int32Range `json:"maxConnections"`
 	CMaxReuseTimes   Int32Range `json:"cMaxReuseTimes"`
-	CMaxLifetimeMs   Int32Range `json:"cMaxLifetimeMs"`
 	HMaxRequestTimes Int32Range `json:"hMaxRequestTimes"`
+	HMaxReusableSecs Int32Range `json:"hMaxReusableSecs"`
 	HKeepAlivePeriod int64      `json:"hKeepAlivePeriod"`
 }
 
@@ -287,10 +287,10 @@ func (c *SplitHTTPConfig) Build() (proto.Message, error) {
 	if c.Xmux == (XmuxConfig{}) {
 		c.Xmux.MaxConcurrency.From = 16
 		c.Xmux.MaxConcurrency.To = 32
-		c.Xmux.CMaxReuseTimes.From = 256
-		c.Xmux.CMaxReuseTimes.To = 512
-		c.Xmux.HMaxRequestTimes.From = 800
+		c.Xmux.HMaxRequestTimes.From = 600
 		c.Xmux.HMaxRequestTimes.To = 900
+		c.Xmux.HMaxReusableSecs.From = 1800
+		c.Xmux.HMaxReusableSecs.To = 3000
 	}
 
 	config := &splithttp.Config{
@@ -308,8 +308,8 @@ func (c *SplitHTTPConfig) Build() (proto.Message, error) {
 			MaxConcurrency:   newRangeConfig(c.Xmux.MaxConcurrency),
 			MaxConnections:   newRangeConfig(c.Xmux.MaxConnections),
 			CMaxReuseTimes:   newRangeConfig(c.Xmux.CMaxReuseTimes),
-			CMaxLifetimeMs:   newRangeConfig(c.Xmux.CMaxLifetimeMs),
 			HMaxRequestTimes: newRangeConfig(c.Xmux.HMaxRequestTimes),
+			HMaxReusableSecs: newRangeConfig(c.Xmux.HMaxReusableSecs),
 			HKeepAlivePeriod: c.Xmux.HKeepAlivePeriod,
 		},
 	}

transport/internet/splithttp/config.go

@@ -64,12 +64,15 @@ func (c *Config) WriteResponseHeader(writer http.ResponseWriter) {
 	}
 }
 
-func (c *Config) GetNormalizedScMaxBufferedPosts() int {
-	if c.ScMaxBufferedPosts == 0 {
-		return 30
+func (c *Config) GetNormalizedXPaddingBytes() RangeConfig {
+	if c.XPaddingBytes == nil || c.XPaddingBytes.To == 0 {
+		return RangeConfig{
+			From: 100,
+			To:   1000,
+		}
 	}
 
-	return int(c.ScMaxBufferedPosts)
+	return *c.XPaddingBytes
 }
 
 func (c *Config) GetNormalizedScMaxEachPostBytes() RangeConfig {
@@ -94,69 +97,67 @@ func (c *Config) GetNormalizedScMinPostsIntervalMs() RangeConfig {
 	return *c.ScMinPostsIntervalMs
 }
 
-func (c *Config) GetNormalizedXPaddingBytes() RangeConfig {
-	if c.XPaddingBytes == nil || c.XPaddingBytes.To == 0 {
-		return RangeConfig{
-			From: 100,
-			To:   1000,
-		}
+func (c *Config) GetNormalizedScMaxBufferedPosts() int {
+	if c.ScMaxBufferedPosts == 0 {
+		return 30
 	}
 
-	return *c.XPaddingBytes
+	return int(c.ScMaxBufferedPosts)
 }
 
-func (m *XmuxConfig) GetNormalizedCMaxRequestTimes() RangeConfig {
-	if m.HMaxRequestTimes == nil {
+func (m *XmuxConfig) GetNormalizedMaxConcurrency() RangeConfig {
+	if m.MaxConcurrency == nil {
 		return RangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
 
-	return *m.HMaxRequestTimes
+	return *m.MaxConcurrency
 }
 
-func (m *XmuxConfig) GetNormalizedCMaxReuseTimes() RangeConfig {
-	if m.CMaxReuseTimes == nil {
+func (m *XmuxConfig) GetNormalizedMaxConnections() RangeConfig {
+	if m.MaxConnections == nil {
 		return RangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
 
-	return *m.CMaxReuseTimes
+	return *m.MaxConnections
 }
 
-func (m *XmuxConfig) GetNormalizedCMaxLifetimeMs() RangeConfig {
-	if m.CMaxLifetimeMs == nil {
+func (m *XmuxConfig) GetNormalizedCMaxReuseTimes() RangeConfig {
+	if m.CMaxReuseTimes == nil {
 		return RangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
-	return *m.CMaxLifetimeMs
+
+	return *m.CMaxReuseTimes
 }
 
-func (m *XmuxConfig) GetNormalizedMaxConnections() RangeConfig {
-	if m.MaxConnections == nil {
+func (m *XmuxConfig) GetNormalizedHMaxRequestTimes() RangeConfig {
+	if m.HMaxRequestTimes == nil {
 		return RangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
 
-	return *m.MaxConnections
+	return *m.HMaxRequestTimes
 }
 
-func (m *XmuxConfig) GetNormalizedMaxConcurrency() RangeConfig {
-	if m.MaxConcurrency == nil {
+func (m *XmuxConfig) GetNormalizedHMaxReusableSecs() RangeConfig {
+	if m.HMaxReusableSecs == nil {
 		return RangeConfig{
 			From: 0,
 			To:   0,
 		}
 	}
 
-	return *m.MaxConcurrency
+	return *m.HMaxReusableSecs
 }
 
 func init() {