Rename dialers into network

main.go

 	"os"
 	"time"
 
-	"github.com/9seconds/mtg/v2/mtglib/dialers"
+	"github.com/9seconds/mtg/v2/mtglib/network"
 )
 
 var version = "dev" // has to be set by ldflags
 
 	fmt.Println(parseRawConfig(f))
 
-	bd, _ := dialers.NewDefaultBaseDialer(0, 0)
-	d, _ := dialers.MakeDialer(bd, "9.9.9.9", 0)
+	bd, _ := network.NewDefaultDialer(0, 0)
+	d, _ := network.NewNetwork(bd, "9.9.9.9", 0)
 
 	r, err := d.HTTP.Get("https://ifconfig.co")
 

mtglib/dialers/socks5.go

-package dialers
-
-import (
-	"fmt"
-	"net/url"
-	"time"
-
-	"golang.org/x/net/proxy"
-)
-
-func NewSocks5BaseDialer(proxyUrl *url.URL, timeout time.Duration, bufferSize int) (BaseDialer, error) {
-	baseDialer, err := NewDefaultBaseDialer(timeout, bufferSize)
-	if err != nil {
-		return nil, fmt.Errorf("cannot initialize base dialer: %w", err)
-	}
-
-	rv, err := proxy.FromURL(proxyUrl, baseDialer.(*defaultBaseDialer))
-	if err != nil {
-		return nil, fmt.Errorf("cannot initialize socks5 proxy dialer: %w", err)
-	}
-
-	return rv.(BaseDialer), nil
-}

mtglib/dialers/consts.go → mtglib/network/consts.go

-package dialers
+package network
 
 import "time"
 

mtglib/dialers/default.go → mtglib/network/default.go

-package dialers
+package network
 
 import (
 	"context"
 	"github.com/libp2p/go-reuseport"
 )
 
-type defaultBaseDialer struct {
+type defaultDialer struct {
 	net.Dialer
 
 	bufferSize int
 }
 
-func (d *defaultBaseDialer) Dial(network, address string) (net.Conn, error) {
+func (d *defaultDialer) Dial(network, address string) (net.Conn, error) {
 	return d.DialContext(context.Background(), network, address)
 }
 
-func (d *defaultBaseDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+func (d *defaultDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	switch network {
 	case "tcp", "tcp4", "tcp6":
 	default:
 	return tcpConn, nil
 }
 
-func NewDefaultBaseDialer(timeout time.Duration, bufferSize int) (BaseDialer, error) {
+func NewDefaultDialer(timeout time.Duration, bufferSize int) (Dialer, error) {
 	switch {
 	case timeout < 0:
 		return nil, fmt.Errorf("timeout %v should be positive number", timeout)
 		bufferSize = DefaultBufferSize
 	}
 
-	return &defaultBaseDialer{
+	return &defaultDialer{
 		Dialer: net.Dialer{
 			Timeout: timeout,
 			Control: reuseport.Control,

mtglib/dialers/interfaces.go → mtglib/network/interfaces.go

-package dialers
+package network
 
 import (
 	"context"
 	"net"
 )
 
-type BaseDialer interface {
-	Dial(network, address string) (net.Conn, error)
+type Dialer interface {
 	DialContext(ctx context.Context, network, address string) (net.Conn, error)
 }

mtglib/dialers/dialer.go → mtglib/network/network.go

-package dialers
+package network
 
 import (
 	"context"
 	doh "github.com/babolivier/go-doh-client"
 )
 
-type Dialer struct {
+type Network struct {
 	HTTP http.Client
 	DNS  doh.Resolver
 
-	baseDialer BaseDialer
+	dialer Dialer
 }
 
-func (d *Dialer) Dial(network, address string) (net.Conn, error) {
+func (d *Network) Dial(network, address string) (net.Conn, error) {
 	return d.DialContext(context.Background(), network, address)
 }
 
-func (d *Dialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+func (d *Network) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
 	host, port, _ := net.SplitHostPort(address)
 
 	ips, err := d.resolveIPs(network, host)
 	})
 
 	for _, v := range ips {
-		if conn, err := d.baseDialer.DialContext(ctx, network, net.JoinHostPort(v, port)); err == nil {
+		if conn, err := d.dialer.DialContext(ctx, network, net.JoinHostPort(v, port)); err == nil {
 			return conn, nil
 		}
 	}
 	return nil, fmt.Errorf("cannot dial to %s:%s", network, address)
 }
 
-func (d *Dialer) resolveIPs(network, address string) ([]string, error) {
+func (d *Network) resolveIPs(network, address string) ([]string, error) {
 	if net.ParseIP(address) != nil {
 		return []string{address}, nil
 	}
 	return ips, nil
 }
 
-func MakeDialer(base BaseDialer, dohHostname string, httpTimeout time.Duration) (*Dialer, error) {
+func NewNetwork(dialer Dialer, dohHostname string, httpTimeout time.Duration) (*Network, error) {
 	switch {
 	case httpTimeout < 0:
 		return nil, fmt.Errorf("timeout should be positive number %v", httpTimeout)
 	dohHTTPClient := &http.Client{
 		Timeout: httpTimeout,
 		Transport: &http.Transport{
-			DialContext: base.DialContext,
+			DialContext: dialer.DialContext,
 		},
 	}
-	rv := &Dialer{
-		baseDialer: base,
+	network := &Network{
+		dialer: dialer,
 		DNS: doh.Resolver{
 			Host:       dohHostname,
 			Class:      doh.IN,
 			HTTPClient: dohHTTPClient,
 		},
 	}
-	rv.HTTP = http.Client{
+	network.HTTP = http.Client{
 		Timeout: httpTimeout,
 		Transport: &http.Transport{
-			DialContext: rv.DialContext,
+			DialContext: network.DialContext,
 		},
 	}
 
-	return rv, nil
+	return network, nil
 }

mtglib/dialers/shadowsocks.go → mtglib/network/shadowsocks.go

-package dialers
+package network
 
 import (
 	"context"
 	shadowsocks "github.com/shadowsocks/go-shadowsocks2/core"
 )
 
-type shadowsocksBaseDialer struct {
-	base   BaseDialer
-	cipher shadowsocks.StreamConnCipher
-}
-
-func (s *shadowsocksBaseDialer) Dial(network, address string) (net.Conn, error) {
-	conn, err := s.base.Dial(network, address)
-	if err != nil {
-		return nil, err
-	}
+type shadowsocksDialer struct {
+	Dialer
 
-	return s.cipher.StreamConn(conn), nil
+	cipher shadowsocks.StreamConnCipher
 }
 
-func (s *shadowsocksBaseDialer) DialContext(ctx context.Context,
+func (s *shadowsocksDialer) DialContext(ctx context.Context,
 	network, address string) (net.Conn, error) {
-	conn, err := s.base.DialContext(ctx, network, address)
+	conn, err := s.Dialer.DialContext(ctx, network, address)
 	if err != nil {
 		return nil, err
 	}
 	return s.cipher.StreamConn(conn), nil
 }
 
-func NewShadowsocksBaseDialer(proxyUrl *url.URL,
-	timeout time.Duration, bufferSize int) (BaseDialer, error) {
+func NewShadowsocksDialer(proxyUrl *url.URL,
+	timeout time.Duration, bufferSize int) (Dialer, error) {
 	username := proxyUrl.User.Username()
 
 	decoded, err := base64.RawURLEncoding.DecodeString(username)
 		return nil, fmt.Errorf("cannot initialize shadowsocks cipher: %w", err)
 	}
 
-	baseDialer, err := NewDefaultBaseDialer(timeout, bufferSize)
+	dialer, err := NewDefaultDialer(timeout, bufferSize)
 	if err != nil {
 		return nil, fmt.Errorf("cannot initialize a base dialer: %w", err)
 
 	}
 
-	return &shadowsocksBaseDialer{
-		base:   baseDialer,
+	return &shadowsocksDialer{
+		Dialer: dialer,
 		cipher: cipher,
 	}, nil
 }

mtglib/network/socks5.go

+package network
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"golang.org/x/net/proxy"
+)
+
+func NewSocks5Dialer(proxyUrl *url.URL, timeout time.Duration, bufferSize int) (Dialer, error) {
+	dialer, err := NewDefaultDialer(timeout, bufferSize)
+	if err != nil {
+		return nil, fmt.Errorf("cannot initialize base dialer: %w", err)
+	}
+
+	rv, err := proxy.FromURL(proxyUrl, dialer.(*defaultDialer))
+	if err != nil {
+		return nil, fmt.Errorf("cannot initialize socks5 proxy dialer: %w", err)
+	}
+
+	return rv.(Dialer), nil
+}