Merge pull request #451 from 9seconds/keepalive-config

Propagate keep alive settings from the config

example.config.toml

 # define a global timeout on establishing of network connections. idle
 # means a timeout on pumping data between sockset when nothing is
 # happening.
-#
 [network.timeout]
 tcp = "5s"
 http = "10s"
 idle = "5m"
 handshake = "10s"
 
+# this defines a configuration for TCP keep alives. Default values are taken
+# from Golang default behavior.
+[network.keep-alive]
+disabled = false
+# idle means a time period after which we start sending TCP Keep Alive probes
+idle = "15s"
+# interval is a period between 2 consecutive probes
+interval = "15s"
+# if we miss that many probes, a connection will be considered as a dead one.
+count = 9
+
 # mtg has to mimic real websites. It does not mean domain fronting, it also
 # means that traffic characteristics should be similar to real world traffic.
 # websites and applications behave differently, their traffic patterns are also

internal/cli/doctor.go

 		conf.Network.Timeout.TCP.Get(10*time.Second),
 		conf.Network.Timeout.HTTP.Get(0),
 		conf.Network.Timeout.Idle.Get(0),
+		net.KeepAliveConfig{
+			Enable:   !conf.Network.KeepAlive.Disabled.Get(false),
+			Idle:     conf.Network.KeepAlive.Idle.Get(0),
+			Interval: conf.Network.KeepAlive.Interval.Get(0),
+			Count:    int(conf.Network.KeepAlive.Count.Get(0)),
+		},
 	)
 
 	fmt.Println("Validate native network connectivity")

internal/cli/run_proxy.go

 		conf.Network.Timeout.TCP.Get(0),
 		conf.Network.Timeout.HTTP.Get(0),
 		conf.Network.Timeout.Idle.Get(0),
+		net.KeepAliveConfig{
+			Enable:   !conf.Network.KeepAlive.Disabled.Get(false),
+			Idle:     conf.Network.KeepAlive.Idle.Get(0),
+			Interval: conf.Network.KeepAlive.Interval.Get(0),
+			Count:    int(conf.Network.KeepAlive.Count.Get(0)),
+		},
 	)
 
 	proxyDialers := make([]mtglib.Network, len(conf.Network.Proxies))

internal/config/config.go

 			Idle      TypeDuration `json:"idle"`
 			Handshake TypeDuration `json:"handshake"`
 		} `json:"timeout"`
+		KeepAlive struct {
+			Disabled TypeBool        `json:"disabled"`
+			Idle     TypeDuration    `json:"idle"`
+			Interval TypeDuration    `json:"interval"`
+			Count    TypeConcurrency `json:"count"`
+		} `json:"keepAlive"`
 		DOHIP   TypeIP         `json:"dohIp"`
 		DNS     TypeDNSURI     `json:"dns"`
 		Proxies []TypeProxyURL `json:"proxies"`

internal/config/parse.go

 			Idle      string `toml:"idle" json:"idle,omitempty"`
 			Handshake string `toml:"handshake" json:"handshake,omitempty"`
 		} `toml:"timeout" json:"timeout,omitempty"`
+		KeepAlive struct {
+			Disabled bool   `toml:"disabled" json:"disabled,omitempty"`
+			Idle     string `toml:"idle" json:"idle,omitempty"`
+			Interval string `toml:"interval" json:"interval,omitempty"`
+			Count    uint   `toml:"count" json:"count,omitempty"`
+		} `toml:"keep-alive" json:"keepAlive,omitempty"`
 		DOHIP   string   `toml:"doh-ip" json:"dohIp,omitempty"`
 		DNS     string   `toml:"dns" json:"dns,omitempty"`
 		Proxies []string `toml:"proxies" json:"proxies,omitempty"`

network/v2/base_http_test.go

 }
 
 func (suite *BaseHTTPTestSuite) SetupTest() {
-	suite.client = network.New(nil, "mtg/1", 0, 0, 0).MakeHTTPClient(nil)
+	suite.client = network.New(nil, "mtg/1", 0, 0, 0, network.DefaultKeepAliveConfig).MakeHTTPClient(nil)
 }
 
 func (suite *BaseHTTPTestSuite) TestGet() {

network/v2/base_network_test.go

 func (suite *BaseNetworkTestSuite) SetupSuite() {
 	suite.EchoServerTestSuite.SetupSuite()
 
-	suite.net = network.New(nil, "agent", 0, 0, 0)
+	suite.net = network.New(nil, "agent", 0, 0, 0, network.DefaultKeepAliveConfig)
 }
 
 func (suite *BaseNetworkTestSuite) TestDialUnknownNetwork() {

network/v2/init.go

 
 import (
 	"errors"
+	"net"
 	"time"
 )
 
 	// DefaultTCPKeepAlivePeriod defines a time period between 2 consecuitive
 	// probes.
 	//
-	// Deprecated: use DefaultKeepAliveIdle and DefaultKeepAliveInterval instead.
+	// Deprecated: use DefaultKeepAliveConfig
 	DefaultTCPKeepAlivePeriod = 10 * time.Second
 
 	// DefaultKeepAliveIdle is the time a connection must be idle before
 	// the first keepalive probe is sent.
+	//
+	// Deprecated: use DefaultKeepAliveConfig
 	DefaultKeepAliveIdle = 30 * time.Second
 
 	// DefaultKeepAliveInterval is the time between consecutive keepalive
 	// probes.
+	//
+	// Deprecated: use DefaultKeepAliveConfig
 	DefaultKeepAliveInterval = 10 * time.Second
 
 	// DefaultKeepAliveCount is the number of unacknowledged probes before
 	// the connection is considered dead.
+	//
+	// Deprecated: use DefaultKeepAliveConfig
 	DefaultKeepAliveCount = 3
 
 	// User Agent to use in HTTP client.
 	tcpLingerTimeout = 1
 )
 
-var ErrCannotDial = errors.New("cannot dial to any address")
+var (
+	ErrCannotDial = errors.New("cannot dial to any address")
+
+	// DefaultKeepAliveConfig defines a default configuration for
+	// keep alive settings. As per official documentation, if keep alive
+	// is enabled, then:
+	//
+	//  Idle = 15 * time.Second
+	//  Interval = 15 * time.Second
+	//  Count = 9
+	DefaultKeepAliveConfig = net.KeepAliveConfig{
+		Enable: true,
+	}
+)

network/v2/network.go

 type network struct {
 	net.Dialer
 
-	httpTimeout time.Duration
-	idleTimeout time.Duration
-	userAgent   string
+	keepAliveConfig net.KeepAliveConfig
+	httpTimeout     time.Duration
+	idleTimeout     time.Duration
+	userAgent       string
 }
 
 func (n *network) Dial(network, address string) (essentials.Conn, error) {
 
 	tcpConn := conn.(*net.TCPConn)
 
-	return tcpConn, setCommonSocketOptions(tcpConn)
+	return tcpConn, setCommonSocketOptions(tcpConn, n.keepAliveConfig)
 }
 
 func (n *network) MakeHTTPClient(
 	tcpTimeout,
 	httpTimeout,
 	idleTimeout time.Duration,
+	keepAliveConfig net.KeepAliveConfig,
 ) mtglib.Network {
 	if dnsResolver == nil {
 		dnsResolver = net.DefaultResolver
 			Resolver:      dnsResolver,
 			FallbackDelay: -1,
 		},
-		userAgent:   userAgent,
-		idleTimeout: idleTimeout,
-		httpTimeout: httpTimeout,
+		userAgent:       userAgent,
+		idleTimeout:     idleTimeout,
+		httpTimeout:     httpTimeout,
+		keepAliveConfig: keepAliveConfig,
 	}
 }

network/v2/sockopts.go

 	"net"
 )
 
-func setCommonSocketOptions(conn *net.TCPConn) error {
-	if err := conn.SetKeepAliveConfig(net.KeepAliveConfig{
-		Enable:   true,
-		Idle:     DefaultKeepAliveIdle,
-		Interval: DefaultKeepAliveInterval,
-		Count:    DefaultKeepAliveCount,
-	}); err != nil {
+func setCommonSocketOptions(conn *net.TCPConn, keepAliveConfig net.KeepAliveConfig) error {
+	if err := conn.SetKeepAliveConfig(keepAliveConfig); err != nil {
 		return fmt.Errorf("cannot configure TCP keepalive: %w", err)
 	}
 

network/v2/sockopts_test.go

 
 	tcpConn := accepted.(*net.TCPConn)
 
-	err = setCommonSocketOptions(tcpConn)
+	err = setCommonSocketOptions(tcpConn, DefaultKeepAliveConfig)
 	require.NoError(t, err)
 
 	rawConn, err := tcpConn.SyscallConn()
 
 		idle, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, tcpKeepIdleOption())
 		require.NoError(t, err)
-		require.Equal(t, int(DefaultKeepAliveIdle.Seconds()), idle, "keepalive idle should match DefaultKeepAliveIdle")
+		require.Equal(t, 15, idle, "keepalive idle should match DefaultKeepAliveIdle")
 
 		interval, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPINTVL)
 		require.NoError(t, err)
-		require.Equal(t, int(DefaultKeepAliveInterval.Seconds()), interval, "keepalive interval should match DefaultKeepAliveInterval")
+		require.Equal(t, 15, interval, "keepalive interval should match DefaultKeepAliveInterval")
 
 		count, err := unix.GetsockoptInt(int(fd), syscall.IPPROTO_TCP, unix.TCP_KEEPCNT)
 		require.NoError(t, err)
-		require.Equal(t, DefaultKeepAliveCount, count, "keepalive count should match DefaultKeepAliveCount")
+		require.Equal(t, 9, count, "keepalive count should match DefaultKeepAliveCount")
 	})
 	require.NoError(t, err)
 }

network/v2/socks_proxy_test.go

 	require.NoError(suite.T(), err)
 	suite.authURL = parsed
 
-	suite.baseNetwork = network.New(nil, "mtg", 0, 0, 0)
+	suite.baseNetwork = network.New(nil, "mtg", 0, 0, 0, network.DefaultKeepAliveConfig)
 }
 
 func (suite *SocksProxyTestSuite) TestIncorrectSchema() {