Linting

internal/cli/run_proxy.go

 func makeIPBlocklist(conf config.ListConfig,
 	logger mtglib.Logger,
 	ntw mtglib.Network,
-	updateCallback ipblocklist.FireholUpdateCallback) (mtglib.IPBlocklist, error) {
+	updateCallback ipblocklist.FireholUpdateCallback,
+) (mtglib.IPBlocklist, error) {
 	if !conf.Enabled.Get(false) {
 		return ipblocklist.NewNoop(), nil
 	}

internal/testlib/mtglib_network_mock.go

 }
 
 func (m *MtglibNetworkMock) MakeHTTPClient(dialFunc func(ctx context.Context,
-	network, address string) (essentials.Conn, error)) *http.Client {
+	network, address string) (essentials.Conn, error),
+) *http.Client {
 	return m.Called(dialFunc).Get(0).(*http.Client) // nolint: forcetypeassert
 }

ipblocklist/firehol.go

 
 func (f *Firehol) updateFromFile(mutex sync.Locker,
 	ranger cidranger.Ranger,
-	scanner *bufio.Scanner) error {
+	scanner *bufio.Scanner,
+) error {
 	for scanner.Scan() {
 		text := scanner.Text()
 		text = fireholRegexpComment.ReplaceAllLiteralString(text, "")
 	downloadConcurrency uint,
 	urls []string,
 	localFiles []string,
-	updateCallback FireholUpdateCallback) (*Firehol, error) {
+	updateCallback FireholUpdateCallback,
+) (*Firehol, error) {
 	blocklists := []files.File{}
 
 	for _, v := range localFiles {
 func NewFireholFromFiles(logger mtglib.Logger,
 	downloadConcurrency uint,
 	blocklists []files.File,
-	updateCallback FireholUpdateCallback) (*Firehol, error) {
+	updateCallback FireholUpdateCallback,
+) (*Firehol, error) {
 	if downloadConcurrency == 0 {
 		downloadConcurrency = DefaultFireholDownloadConcurrency
 	}

mtglib/internal/obfuscated2/client_handshake_fuzz_internal_test.go

 	"github.com/stretchr/testify/require"
 )
 
-var FuzzClientHandshakeSecret = []byte{1,2,3}
+var FuzzClientHandshakeSecret = []byte{1, 2, 3}
 
 func FuzzClientHandshake(f *testing.F) {
-	f.Add([]byte{1,2,3})
+	f.Add([]byte{1, 2, 3})
 
 	f.Fuzz(func(t *testing.T, frame []byte) {
 		data := bytes.NewReader(frame)

mtglib/internal/obfuscated2/init_test.go

 	return ServerHandshakeTestData{
 		connMock: connMock,
 		proxyConn: obfuscated2.Conn{
-			Conn: connMock,
+			Conn:      connMock,
 			Encryptor: handshakeEnc,
 			Decryptor: handshakeDec,
 		},

mtglib/internal/obfuscated2/server_handshake_fuzz_internal_test.go

 		assert.NotEqualValues(
 			t,
 			0,
-			frame.data[4] | frame.data[5] | frame.data[6] | frame.data[7])
+			frame.data[4]|frame.data[5]|frame.data[6]|frame.data[7])
 
 		assert.Equal(t, handshakeConnectionType, frame.connectionType())
 	})

mtglib/internal/obfuscated2/server_handshake_fuzz_test.go

 )
 
 func FuzzServerSend(f *testing.F) {
-	f.Add([]byte{1,2,3,4,5})
+	f.Add([]byte{1, 2, 3, 4, 5})
 
 	f.Fuzz(func(t *testing.T, data []byte) {
 		handshakeData := NewServerHandshakeTestData(t)
 }
 
 func FuzzServerReceive(f *testing.F) {
-	f.Add([]byte{1,2,3,4,5})
+	f.Add([]byte{1, 2, 3, 4, 5})
 
 	f.Fuzz(func(t *testing.T, data []byte) {
 		handshakeData := NewServerHandshakeTestData(t)

network/circuit_breaker.go

 }
 
 func (c *circuitBreakerDialer) DialContext(ctx context.Context,
-	network, address string) (essentials.Conn, error) {
+	network, address string,
+) (essentials.Conn, error) {
 	switch atomic.LoadUint32(&c.state) {
 	case circuitBreakerStateClosed:
 		return c.doClosed(ctx, network, address)
 }
 
 func (c *circuitBreakerDialer) doClosed(ctx context.Context,
-	network, address string) (essentials.Conn, error) {
+	network, address string,
+) (essentials.Conn, error) {
 	conn, err := c.Dialer.DialContext(ctx, network, address)
 
 	select {
 }
 
 func (c *circuitBreakerDialer) doHalfOpened(ctx context.Context,
-	network, address string) (essentials.Conn, error) {
+	network, address string,
+) (essentials.Conn, error) {
 	if !atomic.CompareAndSwapUint32(&c.halfOpenAttempts, 0, 1) {
 		return nil, ErrCircuitBreakerOpened
 	}
 }
 
 func (c *circuitBreakerDialer) ensureTimer(timerRef **time.Timer,
-	timeout time.Duration, callback func()) {
+	timeout time.Duration, callback func(),
+) {
 	if *timerRef == nil {
 		*timerRef = time.AfterFunc(timeout, callback)
 	}
 }
 
 func newCircuitBreakerDialer(baseDialer Dialer,
-	openThreshold uint32, halfOpenTimeout, resetFailuresTimeout time.Duration) Dialer {
+	openThreshold uint32, halfOpenTimeout, resetFailuresTimeout time.Duration,
+) Dialer {
 	cb := &circuitBreakerDialer{
 		Dialer:               baseDialer,
 		stateMutexChan:       make(chan bool, 1),

network/network.go

 }
 
 func (n *network) MakeHTTPClient(dialFunc func(ctx context.Context,
-	network, address string) (essentials.Conn, error)) *http.Client {
+	network, address string) (essentials.Conn, error),
+) *http.Client {
 	if dialFunc == nil {
 		dialFunc = n.DialContext
 	}
 // It brings simple DNS cache and DNS-Over-HTTPS when necessary.
 func NewNetwork(dialer Dialer,
 	userAgent, dohHostname string,
-	httpTimeout 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)
 
 func makeHTTPClient(userAgent string,
 	timeout time.Duration,
-	dialFunc func(ctx context.Context, network, address string) (essentials.Conn, error)) *http.Client {
+	dialFunc func(ctx context.Context, network, address string) (essentials.Conn, error),
+) *http.Client {
 	return &http.Client{
 		Timeout: timeout,
 		Transport: networkHTTPTransport{

stats/statsd.go

 //
 // Valid tagFormats are 'datadog', 'influxdb' and 'graphite'.
 func NewStatsd(address string, log logger.StdLikeLogger,
-	metricPrefix, tagFormat string) (StatsdFactory, error) {
+	metricPrefix, tagFormat string,
+) (StatsdFactory, error) {
 	options := []statsd.Option{
 		statsd.MetricPrefix(metricPrefix),
 		statsd.Logger(log),