write TcpListenerConfig in protobuf

command/src/command.proto

@@ -50,8 +50,20 @@ message HttpsListenerConfig {
     optional string key = 19;
 }
 
-
-
+// details of an TCP listener
+message TcpListenerConfig {
+    required string address = 1;
+    optional string public_address = 2;
+    required bool expect_proxy = 3 [default = false];
+    // client inactive time, in seconds
+    required uint32 front_timeout = 4 [default = 60];
+    // backend server inactive time, in seconds
+    required uint32 back_timeout = 5 [default = 30];
+    // time to connect to the backend, in seconds
+    required uint32 connect_timeout = 6 [default = 3];
+    // wether the listener is actively listening on its socket
+    required bool active = 7 [default = false];
+}
 
 message RequestHttpFrontend {
     optional string cluster_id = 1;

command/src/config.rs

@@ -17,10 +17,10 @@ use crate::{
     proto::command::{
         AddBackend, AddCertificate, CertificateAndKey, Cluster, HttpListenerConfig,
         HttpsListenerConfig, LoadBalancingAlgorithms, LoadBalancingParams, LoadMetric, PathRule,
-        ProxyProtocolConfig, RequestHttpFrontend, RequestTcpFrontend, RulePosition, TlsVersion,
+        ProxyProtocolConfig, RequestHttpFrontend, RequestTcpFrontend, RulePosition,
+        TcpListenerConfig, TlsVersion,
     },
     request::{ActivateListener, ListenerType, Request, WorkerRequest},
-    response::TcpListenerConfig,
 };
 
 /// [`DEFAULT_RUSTLS_CIPHER_LIST`] provides all supported cipher suites exported by Rustls TLS

command/src/request.rs

@@ -14,8 +14,9 @@ use crate::{
         HttpsListenerConfig, LoadBalancingAlgorithms, MetricsConfiguration, PathRuleKind,
         QueryClusterByDomain, QueryMetricsOptions, RemoveBackend, RemoveCertificate,
         ReplaceCertificate, RequestHttpFrontend, RequestTcpFrontend, RulePosition,
+        TcpListenerConfig,
     },
-    response::{HttpFrontend, MessageId, TcpListenerConfig},
+    response::{HttpFrontend, MessageId},
     state::ClusterId,
 };
 

command/src/response.rs

@@ -10,10 +10,10 @@ use crate::{
     proto::command::{
         AddBackend, AggregatedMetrics, CertificateSummary, Cluster, FilteredTimeSerie,
         HttpListenerConfig, HttpsListenerConfig, LoadBalancingParams, PathRule, PathRuleKind,
-        RequestHttpFrontend, RequestTcpFrontend, RulePosition, RunState, TlsVersion, WorkerInfo,
-        WorkerMetrics,
+        RequestHttpFrontend, RequestTcpFrontend, RulePosition, RunState, TcpListenerConfig,
+        WorkerInfo, WorkerMetrics,
     },
-    request::{default_sticky_name, is_false, PROTOCOL_VERSION},
+    request::PROTOCOL_VERSION,
     state::{ClusterId, ConfigState},
 };
 
@@ -296,24 +296,6 @@ pub struct ListenersList {
     pub tcp_listeners: HashMap<String, TcpListenerConfig>,
 }
 
-// TODO: implement Default
-/// details of an TCP listener, sent by the main process to the worker
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct TcpListenerConfig {
-    pub address: String,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub public_address: Option<String>,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "is_false")]
-    pub expect_proxy: bool,
-    pub front_timeout: u32,
-    pub back_timeout: u32,
-    pub connect_timeout: u32,
-    /// should default to false
-    pub active: bool,
-}
-
 impl fmt::Display for RunState {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{self:?}")

command/src/state.rs

@@ -16,10 +16,10 @@ use crate::{
     proto::command::{
         AddBackend, AddCertificate, CertificateAndKey, Cluster, HttpListenerConfig,
         HttpsListenerConfig, PathRule, RemoveBackend, RemoveCertificate, ReplaceCertificate,
-        RequestHttpFrontend, RequestTcpFrontend,
+        RequestHttpFrontend, RequestTcpFrontend, TcpListenerConfig,
     },
     request::{ActivateListener, DeactivateListener, ListenerType, RemoveListener, Request},
-    response::{Backend, ClusterInformation, HttpFrontend, TcpFrontend, TcpListenerConfig},
+    response::{Backend, ClusterInformation, HttpFrontend, TcpFrontend},
 };
 
 /// To use throughout Sōzu
@@ -1599,12 +1599,7 @@ mod tests {
         state
             .dispatch(&Request::AddTcpListener(TcpListenerConfig {
                 address: "0.0.0.0:1234".parse().unwrap(),
-                public_address: None,
-                expect_proxy: false,
-                front_timeout: 60,
-                back_timeout: 30,
-                connect_timeout: 3,
-                active: false,
+                ..Default::default()
             }))
             .expect("Could not execute request");
         state
@@ -1641,12 +1636,8 @@ mod tests {
         state2
             .dispatch(&Request::AddTcpListener(TcpListenerConfig {
                 address: "0.0.0.0:1234".parse().unwrap(),
-                public_address: None,
                 expect_proxy: true,
-                front_timeout: 60,
-                back_timeout: 30,
-                connect_timeout: 3,
-                active: false,
+                ..Default::default()
             }))
             .expect("Could not execute request");
         state2
@@ -1687,12 +1678,8 @@ mod tests {
             }),
             Request::AddTcpListener(TcpListenerConfig {
                 address: "0.0.0.0:1234".parse().unwrap(),
-                public_address: None,
                 expect_proxy: true,
-                front_timeout: 60,
-                back_timeout: 30,
-                connect_timeout: 3,
-                active: false,
+                ..Default::default()
             }),
             Request::DeactivateListener(DeactivateListener {
                 address: "0.0.0.0:1234".parse().unwrap(),

lib/examples/tcp.rs

@@ -10,9 +10,8 @@ use anyhow::Context;
 use sozu_command::{
     channel::Channel,
     logging::{Logger, LoggerBackend},
-    proto::command::{AddBackend, LoadBalancingParams, RequestTcpFrontend},
+    proto::command::{AddBackend, LoadBalancingParams, RequestTcpFrontend, TcpListenerConfig},
     request::{Request, WorkerRequest},
-    response::TcpListenerConfig,
 };
 
 fn main() -> anyhow::Result<()> {
@@ -41,12 +40,7 @@ fn main() -> anyhow::Result<()> {
         let buffer_size = 16384;
         let listener = TcpListenerConfig {
             address: "127.0.0.1:8080".parse().expect("could not parse address"),
-            public_address: None,
-            expect_proxy: false,
-            front_timeout: 60,
-            back_timeout: 30,
-            connect_timeout: 3,
-            active: false,
+            ..Default::default()
         };
         Logger::init(
             "TCP".to_string(),

lib/src/server.rs

@@ -18,14 +18,11 @@ use sozu_command::{
     config::Config,
     proto::command::{
         AddBackend, Cluster, HttpListenerConfig, HttpsListenerConfig, LoadBalancingAlgorithms,
-        LoadMetric, RemoveBackend,
+        LoadMetric, RemoveBackend, TcpListenerConfig as CommandTcpListener,
     },
     ready::Ready,
     request::{ActivateListener, DeactivateListener, ListenerType, Request, WorkerRequest},
-    response::{
-        Event, MessageId, ResponseContent, ResponseStatus, TcpListenerConfig as CommandTcpListener,
-        WorkerResponse,
-    },
+    response::{Event, MessageId, ResponseContent, ResponseStatus, WorkerResponse},
     scm_socket::{Listeners, ScmSocket},
     state::{get_certificate, get_cluster_ids_by_domain, ConfigState},
 };

lib/src/tcp.rs

@@ -35,10 +35,10 @@ use crate::{
     socket::server_bind,
     sozu_command::{
         logging,
-        proto::command::{ProxyProtocolConfig, RequestTcpFrontend},
+        proto::command::{ProxyProtocolConfig, RequestTcpFrontend, TcpListenerConfig},
         ready::Ready,
         request::{Request, WorkerRequest},
-        response::{Event, TcpListenerConfig, WorkerResponse},
+        response::{Event, WorkerResponse},
         scm_socket::ScmSocket,
         state::ClusterId,
     },
@@ -1802,12 +1802,7 @@ mod tests {
             let mut configuration = TcpProxy::new(registry, sessions.clone(), backends.clone());
             let listener_config = TcpListenerConfig {
                 address: "127.0.0.1:1234".to_string(),
-                public_address: None,
-                expect_proxy: false,
-                front_timeout: 60,
-                back_timeout: 30,
-                connect_timeout: 3,
-                active: false,
+                ..Default::default()
             };
 
             {