whole lota lint

.golangci.yml

···
-# This code is licensed under the terms of the MIT license.
-
-## Golden config for golangci-lint v1.50.1
-#
-# This is the best config for golangci-lint based on my experience and opinion.
-# It is very strict, but not extremely strict.
-# Feel free to adopt and change it for your needs.
-#
-# @neilotoole: ^^ Well, it's less strict now!
-# Based on: https://gist.github.com/maratori/47a4d00457a92aa426dbd48a18776322
-
-run:
-  # Timeout for analysis, e.g. 30s, 5m.
-  # Default: 1m
-  timeout: 5m
-
-  tests: true
-
-  skip-dirs:
-    # Skip jcolorenc because big chunks of it are copied from
-    # another encoder, and it uses a bunch of unsafe etc.
-    - cli/output/jsonw/internal/jcolorenc
-
-    # go-udiff is an internal fork of a package for which there
-    # is an open issue. Hopefully we can just rely on the original
-    # package at some point.
-    # See: https://github.com/aymanbagabas/go-udiff/issues/5
-    - cli/diff/internal/go-udiff
-
-    # This package is such a mess, and needs to be rewritten completely.
-    - cli/output/tablew/internal
-
-    # Non-committed scratch dir
-    - scratch
-
-output:
-  sort-results: true
-
-# This file contains only configs which differ from defaults.
-# All possible options can be found here https://github.com/golangci/golangci-lint/blob/master/.golangci.reference.yml
-linters-settings:
-  cyclop:
-    # The maximal code complexity to report.
-    # Default: 10
-    max-complexity: 50
-    # The maximal average package complexity.
-    # If it's higher than 0.0 (float) the check is enabled
-    # Default: 0.0
-    package-average: 10.0
-
-  errcheck:
-    # Report about not checking of errors in type assertions: `a := b.(MyStruct)`.
-    # Such cases aren't reported by default.
-    # Default: false
-    check-type-assertions: true
-
-  exhaustive:
-    # Program elements to check for exhaustiveness.
-    # Default: [ switch ]
-    check:
-      - switch
-      - map
-
-  funlen:
-    # Checks the number of lines in a function.
-    # If lower than 0, disable the check.
-    # Default: 60
-    lines: 150
-    # Checks the number of statements in a function.
-    # If lower than 0, disable the check.
-    # Default: 40
-    statements: 100
-
-  gocognit:
-    # Minimal code complexity to report
-    # Default: 30 (but we recommend 10-20)
-    min-complexity: 50
-
-  gocritic:
-    # Settings passed to gocritic.
-    # The settings key is the name of a supported gocritic checker.
-    # The list of supported checkers can be find in https://go-critic.github.io/overview.
-    settings:
-      captLocal:
-        # Whether to restrict checker to params only.
-        # Default: true
-        paramsOnly: false
-      underef:
-        # Whether to skip (*x).method() calls where x is a pointer receiver.
-        # Default: true
-        skipRecvDeref: false
-
-  gocyclo:
-    # Minimal code complexity to report.
-    # Default: 30 (but we recommend 10-20)
-    min-complexity: 50
-
-  gofumpt:
-    # Module path which contains the source code being formatted.
-    # Default: ""
-    module-path: github.com/neilotoole/sq
-    # Choose whether to use the extra rules.
-    # Default: false
-    extra-rules: true
-
-  gomnd:
-    # List of function patterns to exclude from analysis.
-    # Values always ignored: `time.Date`,
-    # `strconv.FormatInt`, `strconv.FormatUint`, `strconv.FormatFloat`,
-    # `strconv.ParseInt`, `strconv.ParseUint`, `strconv.ParseFloat`.
-    # Default: []
-    ignored-functions:
-      - make
-      - os.Chmod
-      - os.Mkdir
-      - os.MkdirAll
-      - os.OpenFile
-      - os.WriteFile
-      - prometheus.ExponentialBuckets
-      - prometheus.ExponentialBucketsRange
-      - prometheus.LinearBuckets
-    ignored-numbers:
-      - "2"
-      - "3"
-
-  gomodguard:
-    blocked:
-      # List of blocked modules.
-      # Default: []
-      modules:
-        - github.com/golang/protobuf:
-            recommendations:
-              - google.golang.org/protobuf
-            reason: "see https://developers.google.com/protocol-buffers/docs/reference/go/faq#modules"
-        - github.com/satori/go.uuid:
-            recommendations:
-              - github.com/google/uuid
-            reason: "satori's package is not maintained"
-        - github.com/gofrs/uuid:
-            recommendations:
-              - github.com/google/uuid
-            reason: "gofrs' package is not go module"
-
-  govet:
-    # Enable all analyzers.
-    # Default: false
-    enable-all: true
-    # Disable analyzers by name.
-    # Run `go tool vet help` to see all analyzers.
-    # Default: []
-    disable:
-      - fieldalignment # too strict
-    # Settings per analyzer.
-    settings:
-      shadow:
-        # Whether to be strict about shadowing; can be noisy.
-        # Default: false
-        strict: false
-
-  lll:
-    # Max line length, lines longer will be reported.
-    # '\t' is counted as 1 character by default, and can be changed with the tab-width option.
-    # Default: 120.
-    line-length: 120
-    # Tab width in spaces.
-    # Default: 1
-    tab-width: 1
-
-  nakedret:
-    # Make an issue if func has more lines of code than this setting, and it has naked returns.
-    # Default: 30
-    max-func-lines: 0
-
-  nestif:
-    # Minimal complexity of if statements to report.
-    # Default: 5
-    min-complexity: 20
-
-  nolintlint:
-    # Exclude following linters from requiring an explanation.
-    # Default: []
-    allow-no-explanation: [ funlen, gocognit, lll ]
-    # Enable to require an explanation of nonzero length after each nolint directive.
-    # Default: false
-    require-explanation: false
-    # Enable to require nolint directives to mention the specific linter being suppressed.
-    # Default: false
-    require-specific: true
-
-  rowserrcheck:
-    # database/sql is always checked
-    # Default: []
-    packages:
-      - github.com/jmoiron/sqlx
-
-  tenv:
-    # The option `all` will run against whole test files (`_test.go`) regardless of method/function signatures.
-    # Otherwise, only methods that take `*testing.T`, `*testing.B`, and `testing.TB` as arguments are checked.
-    # Default: false
-    all: true
-
-
-linters:
-  disable-all: true
-
-  enable:
-    ## enabled by default
-    - errcheck # checking for unchecked errors, these unchecked errors can be critical bugs in some cases
-    - gosimple # specializes in simplifying a code
-    - govet # reports suspicious constructs, such as Printf calls whose arguments do not align with the format string
-    - ineffassign # detects when assignments to existing variables are not used
-    - staticcheck # is a go vet on steroids, applying a ton of static analysis checks
-    - typecheck # like the front-end of a Go compiler, parses and type-checks Go code
-    - unused # checks for unused constants, variables, functions and types
-
-
-#    ## disabled by default
-    - asasalint # checks for pass []any as any in variadic func(...any)
-    - asciicheck # checks that your code does not contain non-ASCII identifiers
-    - bidichk # checks for dangerous unicode character sequences
-    - bodyclose # checks whether HTTP response body is closed successfully
-    - cyclop # checks function and package cyclomatic complexity
-    - dupl # tool for code clone detection
-    - durationcheck # checks for two durations multiplied together
-    - errname # checks that sentinel errors are prefixed with the Err and error types are suffixed with the Error
-    - errorlint # finds code that will cause problems with the error wrapping scheme introduced in Go 1.13
-    - execinquery # checks query string in Query function which reads your Go src files and warning it finds
-    - exhaustive # checks exhaustiveness of enum switch statements
-    - exportloopref # checks for pointers to enclosing loop variables
-    - forbidigo # forbids identifiers
-    - funlen # tool for detection of long functions
-    - gochecknoinits # checks that no init functions are present in Go code
-    - gocognit # computes and checks the cognitive complexity of functions
-    - goconst # finds repeated strings that could be replaced by a constant
-    - gocritic # provides diagnostics that check for bugs, performance and style issues
-    - gocyclo # computes and checks the cyclomatic complexity of functions
-    - godot # checks if comments end in a period
-    - gofumpt
-    - goimports # in addition to fixing imports, goimports also formats your code in the same style as gofmt
-#    - gomoddirectives # manages the use of 'replace', 'retract', and 'excludes' directives in go.mod
-    - gomodguard # allow and block lists linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations
-    - goprintffuncname # checks that printf-like functions are named with f at the end
-    - gosec # inspects source code for security problems
-    - lll # reports long lines
-    - loggercheck # checks key value pairs for common logger libraries (kitlog,klog,logr,zap)
-    - makezero # finds slice declarations with non-zero initial length
-    - nakedret # finds naked returns in functions greater than a specified function length
-    - nestif # reports deeply nested if statements
-    - nilerr # finds the code that returns nil even if it checks that the error is not nil
-    - nilnil # checks that there is no simultaneous return of nil error and an invalid value
-    - noctx # finds sending http request without context.Context
-    - nolintlint # reports ill-formed or insufficient nolint directives
-    - nosprintfhostport # checks for misuse of Sprintf to construct a host with port in a URL
-    - predeclared # finds code that shadows one of Go's predeclared identifiers
-    - promlinter # checks Prometheus metrics naming via promlint
-    - reassign # checks that package variables are not reassigned
-    - revive # fast, configurable, extensible, flexible, and beautiful linter for Go, drop-in replacement of golint
-    - stylecheck # is a replacement for golint
-    - tenv # detects using os.Setenv instead of t.Setenv since Go1.17
-    - testableexamples # checks if examples are testable (have an expected output)
-    - tparallel # detects inappropriate usage of t.Parallel() method in your Go test codes
-    - unconvert # removes unnecessary type conversions
-    - unparam # reports unused function parameters
-    - usestdlibvars # detects the possibility to use variables/constants from the Go standard library
-    - whitespace # detects leading and trailing whitespace
-
-
-issues:
-  # Maximum count of issues with the same text.
-  # Set to 0 to disable.
-  # Default: 3
-  max-same-issues: 3
-
-  exclude-rules:
-    - source: "^//\\s*go:generate\\s"
-      linters: [ lll ]
-    - source: "(noinspection|TODO)"
-      linters: [ godot ]
-    - source: "//noinspection"
-      linters: [ gocritic ]
-    - source: "^\\s+if _, ok := err\\.\\([^.]+\\.InternalError\\); ok {"
-      linters: [ errorlint ]
-    - path: "_test\\.go"
-      linters:
-        - bodyclose
-        - dupl
-        - funlen
-        - goconst
-        - gosec
-        - noctx
-        - wrapcheck

example/main.go

···
 	consumeOnly = flag.Bool("consume-only", false, "just consumes (doesn't start server and doesn't publish)")
 	flag.Parse()
 
-	if *consumeOnly == false {
+	if !*consumeOnly {
 		go sendMessages()
 	}
 
···
 	if err != nil {
 		panic(err)
 	}
-	defer sub.Close()
+
+	defer func() {
+		_ = sub.Close()
+	}()
 
-	sub.SubscribeToTopics([]string{"topic a"})
+	err = sub.SubscribeToTopics([]string{"topic a"})
+	if err != nil {
+		panic(err)
+	}
 
 	consumer := sub.Consume(context.Background())
 	if consumer.Err != nil {
···
 	if err != nil {
 		panic(err)
 	}
-	defer publisher.Close()
+
+	defer func() {
+		_ = publisher.Close()
+	}()
 
 	// send some messages
 	i := 0

example/server/main.go

···
 	if err != nil {
 		log.Fatal(err)
 	}
-	defer srv.Shutdown()
+
+	defer func() {
+		_ = srv.Shutdown()
+	}()
 
 	signals := make(chan os.Signal, 1)
 	signal.Notify(signals, syscall.SIGTERM, syscall.SIGINT)

pubsub/subscriber_test.go

···
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		server.Shutdown()
+		_ = server.Shutdown()
 	})
 }
 

server/server.go

···
 	lis  net.Listener
 
 	mu     sync.Mutex
-	topics map[string]topic
+	topics map[string]*topic
 }
 
 // New creates and starts a new server
···
 
 	srv := &Server{
 		lis:    lis,
-		topics: map[string]topic{},
+		topics: map[string]*topic{},
 	}
 
 	go srv.start()
···
 			// TODO: see if there's a way to check if the peers connection has been ended etc
 			slog.Error("failed to read action from subscriber", "error", err, "peer", peer.Addr())
 
-			s.unsubscribePeerFromAllTopics(*peer)
+			s.unsubscribePeerFromAllTopics(peer)
 
 			return
 		}
···
 			return nil
 		}
 
-		s.unsubscribeToTopics(*peer, topics)
+		s.unsubscribeToTopics(peer, topics)
 		writeStatus(Unsubscribed, "", conn)
 
 		return nil
···
 	s.topics[topicName] = t
 }
 
-func (s *Server) unsubscribeToTopics(peer peer.Peer, topics []string) {
+func (s *Server) unsubscribeToTopics(peer *peer.Peer, topics []string) {
 	for _, topic := range topics {
 		s.removeSubsciberFromTopic(topic, peer)
 	}
 }
 
-func (s *Server) removeSubsciberFromTopic(topicName string, peer peer.Peer) {
+func (s *Server) removeSubsciberFromTopic(topicName string, peer *peer.Peer) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
···
 	delete(t.subscriptions, peer.Addr())
 }
 
-func (s *Server) unsubscribePeerFromAllTopics(peer peer.Peer) {
+func (s *Server) unsubscribePeerFromAllTopics(peer *peer.Peer) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
···
 	defer s.mu.Unlock()
 
 	if topic, ok := s.topics[topicName]; ok {
-		return &topic
+		return topic
 	}
 
 	return nil
···
 	var action Action
 	op := func(conn net.Conn) error {
 		if timeout > 0 {
-			conn.SetReadDeadline(time.Now().Add(timeout))
+			err := conn.SetReadDeadline(time.Now().Add(timeout))
+			if err != nil {
+				slog.Error("failed to set connection read deadline", "error", err, "peer", peer.Addr())
+			}
 		}
 
 		err := binary.Read(conn, binary.BigEndian, &action)

server/server_test.go

···
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
-		srv.Shutdown()
+		_ = srv.Shutdown()
 	})
 
 	return srv
···
 
 func createServerWithExistingTopic(t *testing.T, topicName string) *Server {
 	srv := createServer(t)
-	srv.topics[topicName] = topic{
+	srv.topics[topicName] = &topic{
 		name:          topicName,
 		subscriptions: make(map[net.Addr]subscriber),
 	}
···
 
 	var resp Status
 	err = binary.Read(conn, binary.BigEndian, &resp)
+	require.NoError(t, err)
 
 	assert.Equal(t, expectedRes, int(resp))
 
···
 
 	var resp Status
 	err = binary.Read(conn, binary.BigEndian, &resp)
+	require.NoError(t, err)
 
 	assert.Equal(t, expectedRes, int(resp))
 
···
 
 	var resp Status
 	err = binary.Read(conn, binary.BigEndian, &resp)
+	require.NoError(t, err)
 
 	assert.Equal(t, expectedRes, int(resp))
 
···
 
 	var dataLen uint32
 	err = binary.Read(conn, binary.BigEndian, &dataLen)
+	require.NoError(t, err)
 	assert.Equal(t, len(expectedMessage), int(dataLen))
 
 	buf := make([]byte, dataLen)
···
 
 	var resp Status
 	err = binary.Read(publisherConn, binary.BigEndian, &resp)
+	require.NoError(t, err)
 
 	assert.Equal(t, expectedRes, int(resp))
 
···
 
 	var dataLen uint32
 	err = binary.Read(publisherConn, binary.BigEndian, &dataLen)
+	require.NoError(t, err)
 	assert.Equal(t, len(expectedMessage), int(dataLen))
 
 	buf := make([]byte, dataLen)

server/topic.go

···
 	currentOffset int
 }
 
-func newTopic(name string) topic {
-	return topic{
+func newTopic(name string) *topic {
+	return &topic{
 		name:          name,
 		subscriptions: make(map[net.Addr]subscriber),
 	}
-}
-
-func (t *topic) removeSubscriber(addr net.Addr) {
-	t.mu.Lock()
-	defer t.mu.Unlock()
-
-	slog.Info("removing subscriber", "peer", addr)
-	delete(t.subscriptions, addr)
 }
 
 func (t *topic) sendMessageToSubscribers(msgData []byte) {