Minor formatting issues

.golangci.toml

 
 [linters]
 enable-all = true
-disable = ["gochecknoglobals", "gas", "gomnd", "goerr113", "exhaustivestruct"]
+disable = ["gochecknoglobals", "gas", "goerr113", "exhaustivestruct"]

cli/access.go

 		return fmt.Errorf("cannot init config: %w", err)
 	}
 
-	wg := &sync.WaitGroup{}
 	resp := &accessResponse{}
 	resp.Secret.Base64 = c.conf.Secret.Base64()
 	resp.Secret.Hex = c.conf.Secret.Hex()
 
-	wg.Add(2)
+	wg := &sync.WaitGroup{}
+	wg.Add(2) // nolint: gomnd
 
 	go func() {
 		defer wg.Done()
 
 		ip := c.conf.Network.PublicIP.IPv4.Value(nil)
-
 		if ip == nil {
 			ip = c.getIP("tcp4")
 		}
 		defer wg.Done()
 
 		ip := c.conf.Network.PublicIP.IPv4.Value(nil)
-
 		if ip == nil {
 			ip = c.getIP("tcp6")
 		}
 	wg.Wait()
 
 	encoder := json.NewEncoder(os.Stdout)
-
 	encoder.SetEscapeHTML(false)
 	encoder.SetIndent("", "  ")
 
 	}
 
 	values := url.Values{}
-
 	values.Set("server", ip.String())
 	values.Set("port", strconv.Itoa(int(c.conf.BindTo.PortValue(0))))
 
 			RawQuery: urlQuery,
 		}).String(),
 	}
-
 	rv.TgQrCode = c.makeQRCode(rv.TgURL)
 	rv.TmeQrCode = c.makeQRCode(rv.TmeURL)
 
 
 func (c *Access) makeQRCode(data string) string {
 	values := url.Values{}
-
 	values.Set("qzone", "4")
 	values.Set("format", "svg")
 	values.Set("data", data)

config/config.go

 
 func Parse(rawData []byte) (*Config, error) {
 	rawConf := &configRaw{}
-
-	if err := toml.Unmarshal(rawData, rawConf); err != nil {
-		return nil, fmt.Errorf("cannot parse toml config: %w", err)
-	}
-
 	jsonBuf := &bytes.Buffer{}
-	jsonEncoder := json.NewEncoder(jsonBuf)
+	conf := &Config{}
 
+	jsonEncoder := json.NewEncoder(jsonBuf)
 	jsonEncoder.SetEscapeHTML(false)
 	jsonEncoder.SetIndent("", "")
 
+	if err := toml.Unmarshal(rawData, rawConf); err != nil {
+		return nil, fmt.Errorf("cannot parse toml config: %w", err)
+	}
+
 	if err := jsonEncoder.Encode(rawConf); err != nil {
 		return nil, fmt.Errorf("cannot dump into interim format: %w", err)
 	}
 
-	conf := &Config{}
-
 	if err := json.NewDecoder(jsonBuf).Decode(conf); err != nil {
 		return nil, fmt.Errorf("cannot parse final config: %w", err)
 	}

config/type_error_rate.go

 	"strconv"
 )
 
+const typeErrorRateIgnoreLess = 1e-8
+
 type TypeErrorRate struct {
 	value float64
 }
 }
 
 func (c TypeErrorRate) Value(defaultValue float64) float64 {
-	if c.value < 1e-8 {
+	if c.value < typeErrorRateIgnoreLess {
 		return defaultValue
 	}
 

config/type_metric_prefix.go

 	}
 
 	prefix := string(data)
-
 	if ok, err := regexp.MatchString("^[a-z0-9]+$", prefix); !ok || err != nil {
 		return fmt.Errorf("incorrect metric prefix: %s", prefix)
 	}

mtglib/network/circuit_breaker.go

 	}
 
 	c.failuresCount = 0
-
 	atomic.StoreUint32(&c.halfOpenAttempts, 0)
 	atomic.StoreUint32(&c.state, state)
 }
 
 func (c *circuitBreakerDialer) stopTimer(timerRef **time.Timer) {
 	timer := *timerRef
-
 	if timer == nil {
 		return
 	}

mtglib/network/circuit_breaker_internal_test.go

 		Return(suite.connMock, nil)
 
 	wg := &sync.WaitGroup{}
-
 	wg.Add(5)
 
 	go func() {
 	time.Sleep(500 * time.Millisecond)
 
 	conn, err := suite.d.DialContext(suite.ctx, "tcp", "127.0.0.2")
-
 	suite.NoError(err)
 	suite.Equal("10.0.0.10:80", conn.RemoteAddr().String())
 

mtglib/network/default_test.go

 	suite.HTTPServerTestSuite.SetupSuite()
 
 	d, err := network.NewDefaultDialer(0, 0)
-
 	suite.NoError(err)
 
 	suite.d = d
 
 func (suite *DefaultDialerTestSuite) TestNegativeTimeout() {
 	_, err := network.NewDefaultDialer(-1, 0)
-
 	suite.Error(err)
 }
 
 func (suite *DefaultDialerTestSuite) TestNegativeBufferSize() {
 	_, err := network.NewDefaultDialer(0, -1)
-
 	suite.Error(err)
 }
 
 	_, err := suite.d.DialContext(context.Background(),
 		"udp",
 		suite.HTTPServerAddress())
-
 	suite.Error(err)
 }
 
 	_, err := suite.d.DialContext(context.Background(),
 		"tcp",
 		suite.HTTPServerAddress()+suite.HTTPServerAddress())
-
 	suite.Error(err)
 }
 
 	conn, err := suite.d.DialContext(context.Background(),
 		"tcp",
 		suite.HTTPServerAddress())
-
 	suite.NoError(err)
 	suite.NotNil(conn)
 

mtglib/network/load_balanced_socks5_test.go

 
 func (suite *LoadBalancedSocks5TestSuite) SetupTest() {
 	baseDialer, _ := network.NewDefaultDialer(0, 0)
-
 	lbDialer, err := network.NewLoadBalancedSocks5Dialer(baseDialer, []*url.URL{
 		suite.MakeSocks5URL("user", "password"),
 		suite.MakeSocks5URL("user2", "password"),
 	})
-
 	suite.NoError(err)
 
 	suite.httpClient = suite.MakeHTTPClient(lbDialer)
 	_, err := network.NewLoadBalancedSocks5Dialer(&DialerMock{}, []*url.URL{
 		{Scheme: "http"},
 	})
-
 	suite.Error(err)
 }
 
 func (suite *LoadBalancedSocks5TestSuite) TestCannotDial() {
 	baseDialer := &DialerMock{}
-
 	baseDialer.On("DialContext", mock.Anything, "tcp", "127.0.0.1:1080").
 		Times(network.ProxyDialerOpenThreshold).
 		Return(&net.TCPConn{}, io.EOF)

mtglib/network/network.go

 	}
 
 	var conn net.Conn
-
 	for _, v := range ips {
 		conn, err = n.dialer.DialContext(ctx, protocol, net.JoinHostPort(v, port))
 

mtglib/network/proxy_dialer_internal_test.go

 
 func (suite *ProxyDialerTestSuite) TestSetupDefaults() {
 	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
-
 	suite.EqualValues(ProxyDialerOpenThreshold, d.openThreshold)
 	suite.EqualValues(ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 	suite.EqualValues(ProxyDialerResetFailuresTimeout, d.resetFailuresTimeout)
 
 func (suite *ProxyDialerTestSuite) TestSetupValuesAllOk() {
 	query := url.Values{}
-
 	query.Set("open_threshold", "30")
 	query.Set("reset_failures_timeout", "1s")
 	query.Set("half_open_timeout", "2s")
-
 	suite.u.RawQuery = query.Encode()
-	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 
+	d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 	suite.EqualValues(30, d.openThreshold)
 	suite.EqualValues(2*time.Second, d.halfOpenTimeout)
 	suite.EqualValues(time.Second, d.resetFailuresTimeout)
 		param := v
 		suite.T().Run(v, func(t *testing.T) {
 			query.Set("open_threshold", param)
-
 			suite.u.RawQuery = query.Encode()
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 			assert.EqualValues(t, ProxyDialerOpenThreshold, d.openThreshold)
 		})
 	}
 		param := v
 		suite.T().Run(v, func(t *testing.T) {
 			query.Set("half_open_timeout", param)
-
 			suite.u.RawQuery = query.Encode()
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}
 		param := v
 		suite.T().Run(v, func(t *testing.T) {
 			query.Set("reset_failures_timeout", param)
-
 			suite.u.RawQuery = query.Encode()
-			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 
+			d := newProxyDialer(&DialerMock{}, suite.u).(*circuitBreakerDialer)
 			assert.EqualValues(t, ProxyDialerHalfOpenTimeout, d.halfOpenTimeout)
 		})
 	}

mtglib/secret.go

 
 func (s *Secret) UnmarshalText(data []byte) error {
 	text := string(data)
-
 	if text == "" {
 		return ErrSecretEmpty
 	}

mtglib/secret_test.go

 
 		suite.T().Run(name, func(t *testing.T) {
 			parsed, err := mtglib.ParseSecret(param)
-
 			assert.NoError(t, err)
 			assert.Equal(t, s.Key, parsed.Key)
 			assert.Equal(t, s.Host, parsed.Host)
 
 			newSecret := mtglib.Secret{}
-
 			assert.NoError(t, newSecret.UnmarshalText([]byte(param)))
 			assert.Equal(t, s.Key, newSecret.Key)
 			assert.Equal(t, s.Host, newSecret.Host)
 	copy(s.Key[:], secretData)
 
 	data, err := json.Marshal(&s)
-
 	suite.NoError(err)
 	suite.Equal(string(data), `"7tEcbLvZ7-f-1bwNsiCwlmVnb29nbGUuY29t"`)
 }
 
 		suite.T().Run(param, func(t *testing.T) {
 			_, err := mtglib.ParseSecret(param)
-
 			assert.Error(t, err)
 		})
 	}
 	generated := mtglib.GenerateSecret("google.com")
 
 	parsed, err := mtglib.ParseSecret(generated.Hex())
-
 	suite.NoError(err)
 	suite.Equal(generated.Key, parsed.Key)
 	suite.Equal(generated.Host, parsed.Host)