Change network to accept DialFunc

cli/access.go

 	Hex        bool   `help:"Print secret in hex encoding."`
 }
 
-func (c *Access) Run(cli *CLI) error {
-	if err := c.ReadConfig(cli.Access.ConfigPath); err != nil {
+func (c *Access) Run(cli *CLI, version string) error {
+	if err := c.ReadConfig(cli.Access.ConfigPath, version); err != nil {
 		return fmt.Errorf("cannot init config: %w", err)
 	}
 
 }
 
 func (c *Access) getIP(protocol string) net.IP {
-	client := c.network.MakeHTTPClient(0)
-	client.Transport = &http.Transport{
-		DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
-			return c.network.DialContext(ctx, protocol, address)
-		},
-	}
-
-	c.network.PrepareHTTPClient(client)
-
-	req, err := http.NewRequest(http.MethodGet, "https://ifconfig.co", nil)
-	if err != nil {
-		panic(err)
-	}
+	client := c.network.MakeHTTPClient(func(ctx context.Context, network, address string) (net.Conn, error) {
+		return c.network.DialContext(ctx, protocol, address)
+	})
 
-	resp, err := client.Do(req)
+	resp, err := client.Get("https://ifconfig.co") // nolint: noctx
 	if err != nil {
 		return nil
 	}
 	}
 
 	defer func() {
-		io.Copy(ioutil.Discard, resp.Body)
+		io.Copy(ioutil.Discard, resp.Body) // nolint: errcheck
 		resp.Body.Close()
 	}()
 

cli/base.go

 	conf    *config.Config
 }
 
-func (b *base) ReadConfig(path string) error {
+func (b *base) ReadConfig(path, version string) error {
 	content, err := ioutil.ReadFile(path)
 	if err != nil {
 		return fmt.Errorf("cannot read config file: %w", err)
 		return fmt.Errorf("cannot parse config: %w", err)
 	}
 
-	ntw, err := b.makeNetwork(conf)
+	ntw, err := b.makeNetwork(conf, version)
 	if err != nil {
 		return fmt.Errorf("cannot build a network: %w", err)
 	}
 	return nil
 }
 
-func (b *base) makeNetwork(conf *config.Config) (network.Network, error) {
+func (b *base) makeNetwork(conf *config.Config, version string) (network.Network, error) {
 	tcpTimeout := conf.Network.Timeout.TCP.Value(network.DefaultTimeout)
 	idleTimeout := conf.Network.Timeout.Idle.Value(network.DefaultIdleTimeout)
 	dohIP := conf.Network.DOHIP.Value(net.ParseIP(network.DefaultDOHHostname)).String()
 	bufferSize := conf.TCPBuffer.Value(network.DefaultBufferSize)
+	userAgent := "mtg/" + version
 
 	baseDialer, err := network.NewDefaultDialer(tcpTimeout, int(bufferSize))
 	if err != nil {
 
 	switch len(proxyURLs) {
 	case 0:
-		return network.NewNetwork(baseDialer, dohIP, idleTimeout)
+		return network.NewNetwork(baseDialer, userAgent, dohIP, idleTimeout)
 	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, dohIP, idleTimeout)
+		return network.NewNetwork(socksDialer, userAgent, dohIP, idleTimeout)
 	}
 
 	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
 		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
 	}
 
-	return network.NewNetwork(socksDialer, dohIP, idleTimeout)
+	return network.NewNetwork(socksDialer, userAgent, dohIP, idleTimeout)
 }

cli/cli.go

 package cli
 
-import (
-	"github.com/alecthomas/kong"
-)
+import "github.com/alecthomas/kong"
 
 type CLI struct {
 	GenerateSecret GenerateSecret   `cmd help:"Generate new proxy secret"` // nolint: govet

cli/generate_secret.go

 	Hex      bool   `help:"Print secret in hex encoding."`
 }
 
-func (c *GenerateSecret) Run(cli *CLI) error { // nolint: unparam
+func (c *GenerateSecret) Run(cli *CLI, _ string) error {
 	secret := mtglib.GenerateSecret(cli.GenerateSecret.HostName)
 
 	if cli.GenerateSecret.Hex {

config/type_bytes.go

 	return nil
 }
 
-func (c TypeBytes) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypeBytes) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

config/type_duration.go

 	return nil
 }
 
-func (c TypeDuration) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypeDuration) MarshalText() ([]byte, error) {
 	return []byte(c.value.String()), nil
 }
 

config/type_float.go

 	return nil
 }
 
-func (c *TypeFloat) MarshalText() ([]byte, error) { // nolint: unparam
+func (c *TypeFloat) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

config/type_hostport.go

 	return nil
 }
 
-func (c TypeHostPort) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypeHostPort) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 
 }
 
 func (c TypeHostPort) HostValue(defaultValue net.IP) net.IP {
-    return c.host.Value(defaultValue)
+	return c.host.Value(defaultValue)
 }
 
 func (c TypeHostPort) PortValue(defaultValue uint) uint {
-    return c.port.Value(defaultValue)
+	return c.port.Value(defaultValue)
 }
 
 func (c TypeHostPort) Value(defaultHostValue net.IP, defaultPortValue uint) string {

config/type_http_path.go

 	value string
 }
 
-func (c *TypeHTTPPath) UnmarshalText(data []byte) error { // nolint: unparam
+func (c *TypeHTTPPath) UnmarshalText(data []byte) error {
 	if len(data) > 0 {
 		c.value = "/" + strings.Trim(string(data), "/")
 	}
 	return nil
 }
 
-func (c TypeHTTPPath) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypeHTTPPath) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

config/type_ip.go

 	return nil
 }
 
-func (c *TypeIP) MarshalText() ([]byte, error) { // nolint: unparam
+func (c *TypeIP) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

config/type_metric_prefix.go

 	return nil
 }
 
-func (c TypeMetricPrefix) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypeMetricPrefix) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

config/type_port.go

 	return nil
 }
 
-func (c *TypePort) MarshalJSON() ([]byte, error) { // nolint: unparam
-    return []byte(c.String()), nil
+func (c *TypePort) MarshalJSON() ([]byte, error) {
+	return []byte(c.String()), nil
 }
 
 func (c TypePort) String() string {

config/type_prefer_ip.go

 	return nil
 }
 
-func (c TypePreferIP) MarshalText() ([]byte, error) { // nolint: unparam
+func (c TypePreferIP) MarshalText() ([]byte, error) {
 	return []byte(c.value), nil
 }
 

config/type_url.go

 	return nil
 }
 
-func (c *TypeURL) MarshalText() ([]byte, error) { // nolint: unparam
+func (c *TypeURL) MarshalText() ([]byte, error) {
 	return []byte(c.String()), nil
 }
 

main.go

 		"version":      version,
 	})
 
-	ctx.FatalIfErrorf(ctx.Run(cli))
+	ctx.FatalIfErrorf(ctx.Run(cli, version))
 }

mtglib/network/init.go

 const (
 	DefaultTimeout     = 10 * time.Second
 	DefaultIdleTimeout = time.Minute
-	DefaultHTTPTimeout = 5 * time.Second
 	DefaultBufferSize  = 4096
 
 	ProxyDialerOpenThreshold        = 5
 
 	DefaultDOHHostname = "9.9.9.9"
 
-	DNSTimeout = 5 * time.Second
+	DNSTimeout  = 5 * time.Second
+	HTTPTimeout = 10 * time.Second
 )
 
 var (
 	ErrCannotDialWithAllProxies = errors.New("cannot dial with all proxies")
 )
 
+type DialFunc func(ctx context.Context, protocol, address string) (net.Conn, error)
+
 type Dialer interface {
 	Dial(network, address string) (net.Conn, error)
 	DialContext(ctx context.Context, network, address string) (net.Conn, error)
 	Dialer
 
 	DNSResolve(network, hostname string) (ips []string, err error)
-	MakeHTTPClient(timeout time.Duration) *http.Client
+	MakeHTTPClient(DialFunc) *http.Client
 	IdleTimeout() time.Duration
-	PrepareHTTPClient(*http.Client)
 }

mtglib/network/network.go

 	doh "github.com/babolivier/go-doh-client"
 )
 
+type networkHTTPTransport struct {
+	userAgent string
+	next      http.RoundTripper
+}
+
+func (n networkHTTPTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	req.Header.Set("User-Agent", n.userAgent)
+
+	return n.next.RoundTrip(req)
+}
+
 type network struct {
-	idleTimeout time.Duration
 	dialer      Dialer
 	dns         doh.Resolver
+	idleTimeout time.Duration
+	userAgent   string
 }
 
 func (n *network) Dial(protocol, address string) (net.Conn, error) {
 	return n.idleTimeout
 }
 
-func (n *network) MakeHTTPClient(timeout time.Duration) *http.Client {
-	if timeout <= 0 {
-		timeout = DefaultHTTPTimeout
-	}
-
-	return &http.Client{
-		Timeout: timeout,
-		Transport: &http.Transport{
-			DialContext: n.DialContext,
-		},
+func (n *network) MakeHTTPClient(dialFunc DialFunc) *http.Client {
+	if dialFunc == nil {
+		dialFunc = n.DialContext
 	}
-}
 
-func (n *network) PatchHTTPClient(_ *http.Client) {
+	return makeHTTPClient(n.userAgent, dialFunc)
 }
 
-func NewNetwork(dialer Dialer, dohHostname string, idleTimeout time.Duration) (Network, error) {
+func NewNetwork(dialer Dialer, userAgent, dohHostname string, idleTimeout time.Duration) (Network, error) {
 	switch {
 	case idleTimeout < 0:
 		return nil, fmt.Errorf("timeout should be positive number %s", idleTimeout)
 	return &network{
 		dialer:      dialer,
 		idleTimeout: idleTimeout,
+		userAgent:   userAgent,
 		dns: doh.Resolver{
 			Host:  dohHostname,
 			Class: doh.IN,
 		},
 	}, nil
 }
+
+func makeHTTPClient(userAgent string, dialFunc DialFunc) *http.Client {
+	return &http.Client{
+		Timeout: HTTPTimeout,
+		Transport: networkHTTPTransport{
+			userAgent: userAgent,
+			next: &http.Transport{
+				DialContext: dialFunc,
+			},
+		},
+	}
+}

utils.go

-package main
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-
-	"github.com/9seconds/mtg/v2/config"
-	"github.com/9seconds/mtg/v2/mtglib/network"
-)
-
-func makeNetwork(conf *config.Config) (network.Network, error) {
-	tcpTimeout := conf.Network.Timeout.TCP.Value(network.DefaultTimeout)
-	idleTimeout := conf.Network.Timeout.Idle.Value(network.DefaultIdleTimeout)
-	dohIP := conf.Network.DOHIP.Value(net.ParseIP(network.DefaultDOHHostname)).String()
-	bufferSize := conf.TCPBuffer.Value(network.DefaultBufferSize)
-
-	baseDialer, err := network.NewDefaultDialer(tcpTimeout, int(bufferSize))
-	if err != nil {
-		return nil, fmt.Errorf("cannot build a default dialer: %w", err)
-	}
-
-	proxyURLs := make([]*url.URL, 0, len(conf.Network.Proxies))
-
-	for _, v := range conf.Network.Proxies {
-		if value := v.Value(nil); value != nil {
-			proxyURLs = append(proxyURLs, v.Value(nil))
-		}
-	}
-
-	switch len(proxyURLs) {
-	case 0:
-		return network.NewNetwork(baseDialer, dohIP, idleTimeout)
-	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, dohIP, idleTimeout)
-	}
-
-	socksDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, proxyURLs)
-	if err != nil {
-		return nil, fmt.Errorf("cannot build socks5 dialer: %w", err)
-	}
-
-	return network.NewNetwork(socksDialer, dohIP, idleTimeout)
-}
-
-func exhaustResponse(response *http.Response) {
-	io.Copy(ioutil.Discard, response.Body) // nolint: errcheck
-	response.Body.Close()
-}