Remove idle timeout from network

cli/base.go

 
 func (b *base) makeNetwork(conf *config.Config, version string) (mtglib.Network, error) {
 	tcpTimeout := conf.Network.Timeout.TCP.Value(network.DefaultTimeout)
-	idleTimeout := conf.Network.Timeout.Idle.Value(network.DefaultIdleTimeout)
 	httpTimeout := conf.Network.Timeout.HTTP.Value(network.DefaultHTTPTimeout)
 	dohIP := conf.Network.DOHIP.Value(net.ParseIP(network.DefaultDOHHostname)).String()
 	bufferSize := conf.TCPBuffer.Value(network.DefaultBufferSize)
 
 	switch len(proxyURLs) {
 	case 0:
-		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout, idleTimeout)
+		return network.NewNetwork(baseDialer, userAgent, dohIP, httpTimeout)
 	case 1:
 		socksDialer, err := network.NewSocks5Dialer(baseDialer, proxyURLs[0])
 		if err != nil {
 			return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 		}
 
-		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout, idleTimeout)
+		return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout)
 	}
 
 	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
 		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 	}
 
-	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout, idleTimeout)
+	return network.NewNetwork(socksDialer, userAgent, dohIP, httpTimeout)
 }

ipblocklist/firehol_test.go

 
 func (suite *FireholTestSuite) TestMixed() {
 	dialer, _ := network.NewDefaultDialer(0, 0)
-	ntw, _ := network.NewNetwork(dialer, "mtg", "1.1.1.1", 0, 0)
+	ntw, _ := network.NewNetwork(dialer, "mtg", "1.1.1.1", 0)
 
 	blocklist, err := ipblocklist.NewFirehol(logger.NewNoopLogger(),
 		ntw, 2,

mtglib/init.go

 	"errors"
 	"net"
 	"net/http"
-	"time"
 )
 
 var (
 	Dial(network, address string) (net.Conn, error)
 	DialContext(ctx context.Context, network, address string) (net.Conn, error)
 	MakeHTTPClient(func(ctx context.Context, network, address string) (net.Conn, error)) *http.Client
-	IdleTimeout() time.Duration
 }
 
 type AntiReplayCache interface {

network/init.go

 
 const (
 	DefaultTimeout     = 10 * time.Second
-	DefaultIdleTimeout = time.Minute
 	DefaultHTTPTimeout = 10 * time.Second
 	DefaultBufferSize  = 4096
 

network/network.go

 type network struct {
 	dialer      Dialer
 	dns         doh.Resolver
-	idleTimeout time.Duration
 	httpTimeout time.Duration
 	userAgent   string
 }
 	return makeHTTPClient(n.userAgent, n.httpTimeout, dialFunc)
 }
 
-func (n *network) IdleTimeout() time.Duration {
-	return n.idleTimeout
-}
-
 func (n *network) dnsResolve(protocol, address string) ([]string, error) {
 	if net.ParseIP(address) != nil {
 		return []string{address}, nil
 
 func NewNetwork(dialer Dialer,
 	userAgent, dohHostname string,
-	httpTimeout, idleTimeout time.Duration) (mtglib.Network, error) {
+	httpTimeout time.Duration) (mtglib.Network, error) {
 	switch {
 	case httpTimeout < 0:
 		return nil, fmt.Errorf("timeout should be positive number %s", httpTimeout)
 		httpTimeout = DefaultHTTPTimeout
 	}
 
-	switch {
-	case idleTimeout < 0:
-		return nil, fmt.Errorf("timeout should be positive number %s", idleTimeout)
-	case idleTimeout == 0:
-		idleTimeout = DefaultIdleTimeout
-	}
-
 	if net.ParseIP(dohHostname) == nil {
 		return nil, fmt.Errorf("hostname %s should be IP address", dohHostname)
 	}
 
 	return &network{
 		dialer:      dialer,
-		idleTimeout: idleTimeout,
 		httpTimeout: httpTimeout,
 		userAgent:   userAgent,
 		dns: doh.Resolver{

stats/statsd_test.go

 	"github.com/stretchr/testify/suite"
 )
 
+const statsdSleepTime = 3 * statsd.DefaultFlushInterval
+
 type statsdFakeServer struct {
 	conn *net.UDPConn
 	buf  *bytes.Buffer
 		RemoteIP:  net.ParseIP("10.0.0.10"),
 	})
 
-	time.Sleep(2 * statsd.DefaultFlushInterval)
+	time.Sleep(statsdSleepTime)
 	suite.Equal("mtg.active_connections:+1|g|#ip_type:ipv4", suite.statsdServer.String())
 
 	suite.statsd.EventFinish(mtglib.EventFinish{
 		ConnID:    "connID",
 	})
 
-	time.Sleep(2 * statsd.DefaultFlushInterval)
+	time.Sleep(statsdSleepTime)
 	suite.Contains(suite.statsdServer.String(), "mtg.session_duration")
 }
 
 		CreatedAt: time.Now(),
 	})
 
-	time.Sleep(2 * statsd.DefaultFlushInterval)
+	time.Sleep(statsdSleepTime)
 	suite.Equal("mtg.concurrency_limited:1|c", suite.statsdServer.String())
 }
 
 		RemoteIP:  net.ParseIP("10.0.0.10"),
 	})
 
-	time.Sleep(2 * statsd.DefaultFlushInterval)
+	time.Sleep(statsdSleepTime)
 	suite.Equal("mtg.ip_blocklisted:1|c|#ip_type:ipv4", suite.statsdServer.String())
 }
 

testlib/mtglib_network_mock.go

 	"context"
 	"net"
 	"net/http"
-	"time"
 
 	"github.com/stretchr/testify/mock"
 )
 	network, address string) (net.Conn, error)) *http.Client {
 	return m.Called(dialFunc).Get(0).(*http.Client)
 }
-
-func (m *MtglibNetworkMock) IdleTimeout() time.Duration {
-	return m.Called().Get(0).(time.Duration)
-}