Package HTTP Client:

- Add DNS Mapper to force destination for a fqdn source
- Allow wildcard and multi wildcard for fqdn source
- DNS Mapper create Transport, Dialer & http client
- DNS Mapper allow a config input to customize timeout, limit and TLS config
- DNS Mapper use a gloabl transport connection poller
- DNS Mapper implement DialContext & Dial method for transport
- DNS Mapper use cache to accelerate process
- DNS Mapper cache is only dnsmapper, not DNS cache
- Replace old helper for http client with DNSMapper
- Add default DNSMapper into the main lib of http client
- Allow to overide the default DNS Mapper with a new one
- Add ticker to force clean idle connection every given duration
- "Compatible" with old config, as the default config will be used instead of old client build
- Clean code and fix minor bugs
- Add config component to allow use a global config
- Config Component httpcli can overide default httpcli dns mapper when updated

Package Certificates
- Add function type to impose function that return a slice of rootCA string
- update config/component/tls by replacing mutex with atomic
- optimize some code

Package Config
- expand errors code index to add component httpcli

Package Config/component:
- database: add new validation, that config key existing into viper
- head: add new validation, that config key existing into viper
- http: add new validation, that config key existing into viper
- ldap: add new validation, that config key existing into viper
- log: add new validation, that config key existing into viper
- mail: add new validation, that config key existing into viper
- smtp: add new validation, that config key existing into viper

Package AWS:
- update package following update of httpcli
- use interface for http cli that implement the Do function
- update following the config/component/aws
- rework config/component/aws to use atomic instead of mutex
- update test unit following change

Package Request:
- update following http client update
- use interface of HTTP Client that implement DO function, instead of http client struct pointer
- update config & code following
- apply same modification into config/component/request
- update config/component/request by replacing mutex to atomic

Package Server
- add function Uptime to model to expose the duration since last start

Package Semaphore
- apply change name of constant following bump of lib associated

Package Crypt
- fix bug into reader to remove suffix of EOF if prevent

Package Errors:
- expand index module to add DNS Mapper client

Package HTTP Server:
- update monitor to apply changes

Package Socket:
- add additional check if reading error: if buffer has data, send it to handler before break run

Other:
- bump dependencies

httpcli/cli.go

@@ -28,162 +28,87 @@ package httpcli
 
 import (
 	"context"
-	"crypto/tls"
-	"net"
 	"net/http"
-	"net/url"
 	"sync/atomic"
 	"time"
 
-	liberr "github.com/nabbar/golib/errors"
-	libptc "github.com/nabbar/golib/network/protocol"
-	"golang.org/x/net/http2"
+	libtls "github.com/nabbar/golib/certificates"
+	libdur "github.com/nabbar/golib/duration"
+	htcdns "github.com/nabbar/golib/httpcli/dns-mapper"
 )
 
 const (
-	ClientTimeout30Sec = 30 * time.Second
-	ClientTimeout10Sec = 10 * time.Second
-	ClientTimeout5Sec  = 5 * time.Second
-	ClientTimeout1Sec  = 1 * time.Second
-
-	ClientNetworkTCP = "tcp"
-	ClientNetworkUDP = "udp"
+	ClientTimeout5Sec = 5 * time.Second
 )
 
-var trp = new(atomic.Value)
+var (
+	dns = new(atomic.Value)
+	ctx context.Context
+	cnl context.CancelFunc
+)
 
-func init() {
-	trp.Store(&http.Transport{
-		Proxy:                 http.ProxyFromEnvironment,
-		TLSHandshakeTimeout:   10 * time.Second,
-		DisableKeepAlives:     false,
-		DisableCompression:    false,
-		MaxIdleConns:          100,
-		MaxIdleConnsPerHost:   1,
-		MaxConnsPerHost:       25,
-		IdleConnTimeout:       90 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-		ForceAttemptHTTP2:     true,
-		TLSClientConfig: &tls.Config{
-			MinVersion: tls.VersionTLS12,
-			MaxVersion: tls.VersionTLS13,
+func initDNSMapper() htcdns.DNSMapper {
+	if cnl != nil {
+		cnl()
+	}
+
+	ctx, cnl = context.WithCancel(context.Background())
+
+	return htcdns.New(ctx, &htcdns.Config{
+		DNSMapper:  make(map[string]string),
+		TimerClean: libdur.ParseDuration(3 * time.Minute),
+		Transport: htcdns.TransportConfig{
+			Proxy:                 nil,
+			TLSConfig:             &libtls.Config{},
+			DisableHTTP2:          false,
+			DisableKeepAlive:      false,
+			DisableCompression:    false,
+			MaxIdleConns:          50,
+			MaxIdleConnsPerHost:   5,
+			MaxConnsPerHost:       25,
+			TimeoutGlobal:         libdur.ParseDuration(30 * time.Second),
+			TimeoutKeepAlive:      libdur.ParseDuration(15 * time.Second),
+			TimeoutTLSHandshake:   libdur.ParseDuration(10 * time.Second),
+			TimeoutExpectContinue: libdur.ParseDuration(3 * time.Second),
+			TimeoutIdleConn:       libdur.ParseDuration(30 * time.Second),
+			TimeoutResponseHeader: 0,
 		},
-	})
+	}, nil)
+}
+
+func DefaultDNSMapper() htcdns.DNSMapper {
+	if i := dns.Load(); i == nil {
+		d := initDNSMapper()
+		dns.Store(d)
+		return d
+	} else if d, k := i.(htcdns.DNSMapper); !k {
+		d = initDNSMapper()
+		dns.Store(d)
+		return d
+	} else {
+		return d
+	}
+}
+
+func SetDefaultDNSMapper(d htcdns.DNSMapper) {
+	if d == nil {
+		return
+	}
+
+	if cnl != nil {
+		cnl()
+	}
+
+	dns.Store(d)
 }
 
 type FctHttpClient func() *http.Client
+type FctHttpClientSrv func(servername string) *http.Client
 
 type HttpClient interface {
 	Do(req *http.Request) (*http.Response, error)
 }
 
-func ForceUpdateTransport(cfg *tls.Config, proxyUrl *url.URL) *http.Transport {
-	t := &http.Transport{
-		Proxy:                 http.ProxyFromEnvironment,
-		TLSClientConfig:       cfg.Clone(),
-		TLSHandshakeTimeout:   10 * time.Second,
-		DisableKeepAlives:     false,
-		DisableCompression:    false,
-		MaxIdleConns:          100,
-		MaxIdleConnsPerHost:   1,
-		MaxConnsPerHost:       25,
-		IdleConnTimeout:       90 * time.Second,
-		ExpectContinueTimeout: 1 * time.Second,
-		ForceAttemptHTTP2:     true,
-	}
-
-	if proxyUrl != nil {
-		t.Proxy = http.ProxyURL(proxyUrl)
-	}
-
-	trp.Store(t)
-
-	return t
-}
-
-func GetTransport(tlsConfig *tls.Config, proxyURL *url.URL, DisableKeepAlive, DisableCompression, ForceHTTP2 bool) *http.Transport {
-	var tr *http.Transport
-
-	if i := trp.Load(); i != nil {
-		if t, k := i.(*http.Transport); k {
-			tr = t.Clone()
-		}
-	}
-
-	if tr == nil {
-		tr = &http.Transport{
-			Proxy:                 http.ProxyFromEnvironment,
-			TLSHandshakeTimeout:   10 * time.Second,
-			DisableKeepAlives:     false,
-			DisableCompression:    false,
-			MaxIdleConns:          100,
-			MaxIdleConnsPerHost:   1,
-			MaxConnsPerHost:       25,
-			IdleConnTimeout:       90 * time.Second,
-			ExpectContinueTimeout: 1 * time.Second,
-			ForceAttemptHTTP2:     true,
-		}
-	}
-
-	tr.DisableCompression = DisableCompression
-	tr.DisableKeepAlives = DisableKeepAlive
-	tr.TLSClientConfig = tlsConfig.Clone()
-
-	if proxyURL != nil {
-		tr.Proxy = http.ProxyURL(proxyURL)
-	}
-
-	return tr
-}
-
-func SetTransportDial(tr *http.Transport, forceIp bool, netw libptc.NetworkProtocol, ip, local string) {
-	var (
-		dial = &net.Dialer{
-			Timeout:   30 * time.Second,
-			KeepAlive: 30 * time.Second,
-		}
-		fctDial func(ctx context.Context, network, address string) (net.Conn, error)
-	)
-
-	if forceIp && len(local) > 0 {
-		u := &url.URL{
-			Host: local,
-		}
-		fctDial = func(ctx context.Context, network, address string) (net.Conn, error) {
-			dial.LocalAddr = &net.TCPAddr{
-				IP: net.ParseIP(u.Hostname()),
-			}
-
-			return dial.DialContext(ctx, netw.Code(), ip)
-		}
-	} else if forceIp {
-		fctDial = func(ctx context.Context, network, address string) (net.Conn, error) {
-			return dial.DialContext(ctx, netw.Code(), ip)
-		}
-	} else {
-		fctDial = dial.DialContext
-	}
-
-	tr.DialContext = fctDial
-	tr.DialTLSContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
-		return tls.DialWithDialer(dial, network, addr, tr.TLSClientConfig)
-	}
-}
-
-func GetClient(tr *http.Transport, http2Tr bool, GlobalTimeout time.Duration) (*http.Client, liberr.Error) {
-	if http2Tr {
-		if e := http2.ConfigureTransport(tr); e != nil {
-			return nil, ErrorClientTransportHttp2.Error(e)
-		}
-	}
-
-	c := &http.Client{
-		Transport: tr,
-	}
-
-	if GlobalTimeout != 0 {
-		c.Timeout = GlobalTimeout
-	}
-
-	return c, nil
+func GetClient() *http.Client {
+	return DefaultDNSMapper().DefaultClient()
 }