docs(quic): move desc to i18n.

apps/emqx/i18n/emqx_schema_i18n.conf

@@ -1901,6 +1901,347 @@ base_listener_acceptors {
     }
 }
 
+fields_mqtt_quic_listener_max_bytes_per_key {
+    desc {
+        en: "Maximum number of bytes to encrypt with a single 1-RTT encryption keybefore initiating key update. Default: 274877906944"
+        zh: ""
+    }
+    label {
+        en: "Max bytes per key"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_handshake_idle_timeout_ms {
+    desc {
+        en: "How long a handshake can idle before it is discarded. Default: 10 000"
+        zh: ""
+    }
+    label {
+        en: "Handshake idle timeout ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_tls_server_max_send_buffer {
+    desc {
+        en: "How much Server TLS data to buffer. Default: 8192"
+        zh: ""
+    }
+    label {
+        en: "Tls server max send buffer"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_stream_recv_window_default {
+    desc {
+        en: "Initial stream receive window size. Default: 32678"
+        zh: ""
+    }
+    label {
+        en: "Stream recv window default"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_stream_recv_buffer_default {
+    desc {
+        en: "Stream initial buffer size. Default: 4096"
+        zh: ""
+    }
+    label {
+        en: "Stream recv buffer default"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_conn_flow_control_window {
+    desc {
+        en: "Connection-wide flow control window. Default: 16777216"
+        zh: ""
+    }
+    label {
+        en: "Conn flow control window"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_max_stateless_operations {
+    desc {
+        en: "The maximum number of stateless operations that may be queued on a worker at any one time. Default: 16"
+        zh: ""
+    }
+    label {
+        en: "Max stateless operations"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_initial_window_packets {
+    desc {
+        en: "The size (in packets) of the initial congestion window for a connection. Default: 10"
+        zh: ""
+    }
+    label {
+        en: "Initial window packets"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_send_idle_timeout_ms {
+    desc {
+        en: "Reset congestion control after being idle for amount of time. Default: 1000"
+        zh: ""
+    }
+    label {
+        en: "Send idle timeout ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_initial_rtt_ms {
+    desc {
+        en: "Initial RTT estimate."
+        zh: ""
+    }
+    label {
+        en: "Initial rtt ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_max_ack_delay_ms {
+    desc {
+        en: "How long to wait after receiving data before sending an ACK. Default: 25"
+        zh: ""
+    }
+    label {
+        en: "Max ack delay ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_disconnect_timeout_ms {
+    desc {
+        en: "How long to wait for an ACK before declaring a path dead and disconnecting. Default: 16000"
+        zh: ""
+    }
+    label {
+        en: "Disconnect timeout ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_idle_timeout_ms {
+    desc {
+        en: "How long a connection can go idle before it is gracefully shut down. 0 to disable timeout"
+        zh: ""
+    }
+    label {
+        en: "Idle timeout ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_handshake_idle_timeout_ms {
+    desc {
+        en: "How long a handshake can idle before it is discarded"
+        zh: ""
+    }
+    label {
+        en: "Handshake idle timeout ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_keep_alive_interval_ms {
+    desc {
+        en: "How often to send PING frames to keep a connection alive."
+        zh: ""
+    }
+    label {
+        en: "Keep alive interval ms"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_peer_bidi_stream_count {
+    desc {
+        en: "Number of bidirectional streams to allow the peer to open."
+        zh: ""
+    }
+    label {
+        en: "Peer bidi stream count"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_peer_unidi_stream_count {
+    desc {
+        en: "Number of unidirectional streams to allow the peer to open."
+        zh: ""
+    }
+    label {
+        en: "Peer unidi stream count"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_retry_memory_limit {
+    desc {
+        en: "The percentage of available memory usable for handshake connections beforestateless retry is used. Calculated as `N/65535`. Default: 65"
+        zh: ""
+    }
+    label {
+        en: "Retry memory limit"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_load_balancing_mode {
+    desc {
+        en: "0: Disabled, 1: SERVER_ID_IP, 2: SERVER_ID_FIXED, default: 0"
+        zh: ""
+    }
+    label {
+        en: "Load balancing mode"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_max_operations_per_drain {
+    desc {
+        en: "The maximum number of operations to drain per connection quantum. Default: 16"
+        zh: ""
+    }
+    label {
+        en: "Max operations per drain"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_send_buffering_enabled {
+    desc {
+        en: "Buffer send data instead of holding application buffers untilsent data is acknowledged. Default: 1 (Enabled)"
+        zh: ""
+    }
+    label {
+        en: "Send buffering enabled"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_pacing_enabled {
+    desc {
+        en: "Pace sending to avoid overfilling buffers on the path. Default: 1 (Enabled)"
+        zh: ""
+    }
+    label {
+        en: "Pacing enabled"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_migration_enabled {
+    desc {
+        en: "Enable clients to migrate IP addresses and tuples. Requires a cooperative load-balancer, or no load-balancer. Default: 1 (Enabled)"
+        zh: ""
+    }
+    label {
+        en: "Migration enabled"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_datagram_receive_enabled {
+    desc {
+        en: "Advertise support for QUIC datagram extension. Reserve for the future. Default 0 (FALSE)"
+        zh: ""
+    }
+    label {
+        en: "Datagram receive enabled"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_server_resumption_level {
+    desc {
+        en: "Controls resumption tickets and/or 0-RTT server support. Default: 0 (No resumption)"
+        zh: ""
+    }
+    label {
+        en: "Server resumption level"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_minimum_mtu {
+    desc {
+        en: "The minimum MTU supported by a connection. This will be used as the starting MTU. Default: 1248"
+        zh: ""
+    }
+    label {
+        en: "Minimum mtu"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_maximum_mtu {
+    desc {
+        en: "The maximum MTU supported by a connection. This will be the maximum probed value. Default: 1500"
+        zh: ""
+    }
+    label {
+        en: "Maximum mtu"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_mtu_discovery_search_complete_timeout_us {
+    desc {
+        en: "The time in microseconds to wait before reattempting MTU probing ifmax was not reached. Default: 600000000"
+        zh: ""
+    }
+    label {
+        en: "Mtu discovery search complete timeout us"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_mtu_discovery_missing_probe_count {
+    desc {
+        en: "The maximum number of stateless operations that may be queued on a binding at any one time. Default: 3"
+        zh: ""
+    }
+    label {
+        en: "Mtu discovery missing probe count"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_max_binding_stateless_operations {
+    desc {
+        en: "The maximum number of stateless operations that may be queued ona binding at any one time. Default: 100"
+        zh: ""
+    }
+    label {
+        en: "Max binding stateless operations"
+        zh: ""
+    }
+}
+
+fields_mqtt_quic_listener_stateless_operation_expiration_ms {
+    desc {
+        en: "The time limit between operations for the same endpoint, in milliseconds. Default: 100"
+        zh: ""
+    }
+    label {
+        en: "Stateless operation expiration ms"
+        zh: ""
+    }
+}
+
 base_listener_max_connections {
     desc {
         en: """The maximum number of concurrent connections allowed by the listener."""

apps/emqx/src/emqx_schema.erl

@@ -870,74 +870,73 @@ fields("mqtt_quic_listener") ->
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(64),
-                "Maximum number of bytes to encrypt with a single 1-RTT encryption key"
+                ?DESC(fields_mqtt_quic_listener_max_bytes_per_key)
-                "before initiating key update. Default: 274877906944"
             )},
         {"handshake_idle_timeout_ms",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(64),
-                "How long a handshake can idle before it is discarded. Default: 10 000"
+                ?DESC(fields_mqtt_quic_listener_handshake_idle_timeout)
             )},
         {"tls_server_max_send_buffer",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "How much Server TLS data to buffer. Default: 8192"
+                ?DESC(fields_mqtt_quic_listener_tls_server_max_send_buffer)
             )},
         {"stream_recv_window_default",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "Initial stream receive window size. Default: 32678"
+                ?DESC(fields_mqtt_quic_listener_stream_recv_window_default)
             )},
         {"stream_recv_buffer_default",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "Stream initial buffer size. Default: 4096"
+                ?DESC(fields_mqtt_quic_listener_stream_recv_buffer_default)
             )},
         {"conn_flow_control_window",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "Connection-wide flow control window. Default: 16777216"
+                ?DESC(fields_mqtt_quic_listener_conn_flow_control_window)
             )},
         {"max_stateless_operations",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "The maximum number of stateless operations that may be queued on a worker at any one time. Default: 16"
+                ?DESC(fields_mqtt_quic_listener_max_stateless_operations)
             )},
         {"initial_window_packets",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "The size (in packets) of the initial congestion window for a connection. Default: 10"
+                ?DESC(fields_mqtt_quic_listener_initial_window_packets)
             )},
         {"send_idle_timeout_ms",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "Reset congestion control after being idle for amount of time. Default: 1000"
+                ?DESC(fields_mqtt_quic_listener_send_idle_timeout_ms)
             )},
         {"initial_rtt_ms",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "Initial RTT estimate. Default: 333"
+                ?DESC(fields_mqtt_quic_listener_initial_rtt_ms)
             )},
         {"max_ack_delay_ms",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "How long to wait after receiving data before sending an ACK. Default: 25"
+                ?DESC(fields_mqtt_quic_listener_max_ack_delay_ms)
             )},
         {"disconnect_timeout_ms",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(32),
-                "How long to wait for an ACK before declaring a path dead and disconnecting. Default: 16000"
+                ?DESC(fields_mqtt_quic_listener_disconnect_timeout_ms)
             )},
         {"idle_timeout",
             sc(
@@ -951,7 +950,7 @@ fields("mqtt_quic_listener") ->
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(64),
-                "How long a connection can go idle before it is gracefully shut down. 0 to disable timeout"
+                ?DESC(fields_mqtt_quic_listener_idle_timeout_ms)
             )},
         {"handshake_idle_timeout",
             sc(
@@ -965,7 +964,7 @@ fields("mqtt_quic_listener") ->
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(64),
-                "How long a handshake can idle before it is discarded"
+                ?DESC(fields_mqtt_quic_listener_handshake_idle_timeout_ms)
             )},
         {"keep_alive_interval",
             sc(
@@ -979,100 +978,95 @@ fields("mqtt_quic_listener") ->
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(32),
-                "How often to send PING frames to keep a connection alive. Default: 0 (Disabled)"
+                ?DESC(fields_mqtt_quic_listener_keep_alive_interval_ms)
             )},
         {"peer_bidi_stream_count",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(16),
-                "Number of bidirectional streams to allow the peer to open."
+                ?DESC(fields_mqtt_quic_listener_peer_bidi_stream_count)
             )},
         {"peer_unidi_stream_count",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(16),
-                "Number of unidirectional streams to allow the peer to open."
+                ?DESC(fields_mqtt_quic_listener_peer_unidi_stream_count)
             )},
         {"retry_memory_limit",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(16),
-                "The percentage of available memory usable for handshake connections before"
+                ?DESC(fields_mqtt_quic_listener_retry_memory_limit)
-                "stateless retry is used. Calculated as `N/65535`. Default: 65"
             )},
         {"load_balancing_mode",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(16),
-                "0: Disabled, 1: SERVER_ID_IP, 2: SERVER_ID_FIXED, default: 0"
+                ?DESC(fields_mqtt_quic_listener_load_balancing_mode)
             )},
         {"max_operations_per_drain",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(8),
-                "The maximum number of operations to drain per connection quantum. Default: 16"
+                ?DESC(fields_mqtt_quic_listener_max_operations_per_drain)
             )},
         {"send_buffering_enabled",
             quic_feature_toggle(
-                "Buffer send data instead of holding application buffers until"
+                ?DESC(fields_mqtt_quic_listener_send_buffering_enabled)
-                "sent data is acknowledged. Default: 1 (Enabled)"
             )},
         {"pacing_enabled",
             quic_feature_toggle(
-                "Pace sending to avoid overfilling buffers on the path. Default: 1 (Enabled)"
+                ?DESC(fields_mqtt_quic_listener_pacing_enabled)
             )},
         {"migration_enabled",
             quic_feature_toggle(
-                "Enable clients to migrate IP addresses and tuples. "
+                ?DESC(fields_mqtt_quic_listener_migration_enabled)
-                "Requires a cooperative load-balancer, or no load-balancer. Default: 1 (Enabled)"
             )},
         {"datagram_receive_enabled",
             quic_feature_toggle(
-                "Advertise support for QUIC datagram extension. Reserve for the future. Default 0 (FALSE)"
+                ?DESC(fields_mqtt_quic_listener_datagram_receive_enabled)
             )},
         {"server_resumption_level",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(8),
-                "Controls resumption tickets and/or 0-RTT server support. Default: 0 (No resumption)"
+                ?DESC(fields_mqtt_quic_listener_server_resumption_level)
             )},
         {"minimum_mtu",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(16),
-                "The minimum MTU supported by a connection. This will be used as the starting MTU. Default: 1248"
+                ?DESC(fields_mqtt_quic_listener_minimum_mtu)
             )},
         {"maximum_mtu",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(16),
-                "The maximum MTU supported by a connection. This will be the maximum probed value. Default: 1500"
+                ?DESC(fields_mqtt_quic_listener_maximum_mtu)
             )},
         {"mtu_discovery_search_complete_timeout_us",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(64),
-                "The time in microseconds to wait before reattempting MTU probing if"
+                ?DESC(fields_mqtt_quic_listener_mtu_discovery_search_complete_timeout_us)
-                "max was not reached. Default: 600000000"
             )},
         {"mtu_discovery_missing_probe_count",
             quic_lowlevel_settings_uint(
                 1,
                 ?MAX_UINT(8),
-                "The maximum number of stateless operations that may be queued on a binding at any one time. Default: 3"
+                ?DESC(fields_mqtt_quic_listener_mtu_discovery_missing_probe_count)
             )},
         {"max_binding_stateless_operations",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(16),
-                "The maximum number of stateless operations that may be queued on"
+                ?DESC(fields_mqtt_quic_listener_max_binding_stateless_operations)
-                "a binding at any one time. Default: 100"
             )},
         {"stateless_operation_expiration_ms",
             quic_lowlevel_settings_uint(
                 0,
                 ?MAX_UINT(16),
-                "The time limit between operations for the same endpoint, in milliseconds. Default: 100"
+                ?DESC(fields_mqtt_quic_listener_stateless_operation_expiration_ms)
             )},
         {"ssl_options",
             sc(