golangci-lint action

.github/workflows/lint.yml

@@ -0,0 +1,24 @@
+name: Run lint
+
+on: [ push, pull_request ]
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    strategy:
+      matrix:
+        path:
+          - .
+          - examples
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Lint
+        uses: golangci/golangci-lint-action@v2
+        with:
+          # version of golangci-lint to use in form of v1.2 or v1.2.3 or `latest` to use the latest version
+          version: latest
+          working-directory: ${{ matrix.path }}

.github/workflows/test.yml

@@ -20,18 +20,6 @@ jobs:
         go test -v -race ./...
     - name: Test examples
       run: cd examples && go test -v -race ./...
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Go
-        uses: actions/setup-go@v1
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Lint
-        run: |
-          docker run --rm -v `pwd`:/go/src/k8s.io/klog -w /go/src/k8s.io/klog \
-            golangci/golangci-lint:v1.50.1 golangci-lint run --disable-all -v \
-            -E govet -E misspell -E gofmt -E ineffassign -E golint
   apidiff:
     runs-on: ubuntu-latest
     if: github.base_ref

.golangci.yaml

@@ -0,0 +1,6 @@
+linters:
+  disable-all: true
+  enable: # sorted alphabetical
+    - gofmt
+    - misspell
+    - revive

examples/benchmarks/benchmarks_test.go

@@ -27,6 +27,7 @@ import (
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 )
 
@@ -38,11 +39,11 @@ func init() {
 	// klog gets configured so that it writes to a single output file that
 	// will be set during tests with SetOutput.
 	klog.InitFlags(nil)
-	flag.Set("v", fmt.Sprintf("%d", verbosityThreshold))
-	flag.Set("log_file", "/dev/null")
-	flag.Set("logtostderr", "false")
-	flag.Set("alsologtostderr", "false")
-	flag.Set("stderrthreshold", "10")
+	require.NoError(flag.Set("v", fmt.Sprintf("%d", verbosityThreshold)))
+	require.NoError(flag.Set("log_file", "/dev/null"))
+	require.NoError(flag.Set("logtostderr", "false"))
+	require.NoError(flag.Set("alsologtostderr", "false"))
+	require.NoError(flag.Set("stderrthreshold", "10"))
 }
 
 type testcase struct {

examples/coexist_glog/coexist_glog.go

@@ -4,11 +4,12 @@ import (
 	"flag"
 
 	"github.com/golang/glog"
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 )
 
 func main() {
-	flag.Set("alsologtostderr", "true")
+	require.NoError(flag.Set("alsologtostderr", "true"))
 	flag.Parse()
 
 	klogFlags := flag.NewFlagSet("klog", flag.ExitOnError)
@@ -19,7 +20,7 @@ func main() {
 		f2 := klogFlags.Lookup(f1.Name)
 		if f2 != nil {
 			value := f1.Value.String()
-			f2.Value.Set(value)
+			require.NoError(f2.Value.Set(value))
 		}
 	})
 

examples/flushing/flushing_test.go

@@ -5,6 +5,8 @@ import (
 	"testing"
 
 	"go.uber.org/goleak"
+
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 )
 
@@ -13,8 +15,8 @@ func main() {
 
 	// By default klog writes to stderr. Setting logtostderr to false makes klog
 	// write to a log file.
-	flag.Set("logtostderr", "false")
-	flag.Set("log_file", "myfile.log")
+	require.NoError(flag.Set("logtostderr", "false"))
+	require.NoError(flag.Set("log_file", "myfile.log"))
 	flag.Parse()
 
 	// Info writes the first log message. When the first log file is created,

examples/go.mod

@@ -1,4 +1,4 @@
-module example
+module k8s.io/klog/examples
 
 go 1.13
 

examples/klogr/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 	"k8s.io/klog/v2/klogr"
 )
@@ -17,7 +18,7 @@ func (e myError) Error() string {
 
 func main() {
 	klog.InitFlags(nil)
-	flag.Set("v", "3")
+	require.NoError(flag.Set("v", "3"))
 	flag.Parse()
 	log := klogr.New().WithName("MyName").WithValues("user", "you")
 	log.Info("hello", "val1", 1, "val2", map[string]int{"k": 1})

examples/log_file/usage_log_file.go

@@ -3,15 +3,16 @@ package main
 import (
 	"flag"
 
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
 	// By default klog writes to stderr. Setting logtostderr to false makes klog
 	// write to a log file.
-	flag.Set("logtostderr", "false")
-	flag.Set("log_file", "myfile.log")
+	require.NoError(flag.Set("logtostderr", "false"))
+	require.NoError(flag.Set("log_file", "myfile.log"))
 	flag.Parse()
 	klog.Info("nice to meet you")
 	klog.Flush()

examples/output_test/output_test.go

@@ -34,7 +34,9 @@ import (
 	"k8s.io/klog/v2/textlogger"
 )
 
-func newLogger(out io.Writer, v int, vmodule string) logr.Logger {
+// newLogger is a test.OutputConfig.NewLogger callback which creates a zapr
+// logger. The vmodule parameter is ignored because zapr does not support that.
+func newLogger(out io.Writer, v int, _ string) logr.Logger {
 	return newZaprLogger(out, v)
 }
 

examples/set_output/usage_set_output.go

@@ -4,13 +4,15 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
+
+	"k8s.io/klog/examples/util/require"
 	"k8s.io/klog/v2"
 )
 
 func main() {
 	klog.InitFlags(nil)
-	flag.Set("logtostderr", "false")
-	flag.Set("alsologtostderr", "false")
+	require.NoError(flag.Set("logtostderr", "false"))
+	require.NoError(flag.Set("alsologtostderr", "false"))
 	flag.Parse()
 
 	buf := new(bytes.Buffer)

examples/structured_logging/structured_logging.go

@@ -25,8 +25,9 @@ func main() {
 	flag.Parse()
 
 	someData := MyStruct{
-		Name: "hello",
-		Data: "world",
+		Name:     "hello",
+		Data:     "world",
+		internal: 42,
 	}
 
 	longData := MyStruct{

examples/util/require/require.go

@@ -0,0 +1,7 @@
+package require
+
+func NoError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

exit_test.go

@@ -27,12 +27,15 @@ func ExampleFlushAndExit() {
 
 	var fs flag.FlagSet
 	klog.InitFlags(&fs)
-	fs.Set("skip_headers", "true")
-	defer flag.Set("skip_headers", "false")
-	fs.Set("logtostderr", "false")
-	defer fs.Set("logtostderr", "true")
+	state := klog.CaptureState()
+	defer state.Restore()
+	if err := fs.Set("skip_headers", "true"); err != nil {
+		panic(err)
+	}
+	if err := fs.Set("logtostderr", "false"); err != nil {
+		panic(err)
+	}
 	klog.SetOutput(os.Stdout)
-	defer klog.SetOutput(nil)
 	klog.OsExit = func(exitCode int) {
 		fmt.Printf("os.Exit(%d)\n", exitCode)
 	}

format_test.go

@@ -43,7 +43,7 @@ func TestFormat(t *testing.T) {
 `, klog.Format(obj).(fmt.Stringer).String(), "Format(config).String()")
 	// fmt.Sprintf would call String if it was available.
 	str := fmt.Sprintf("%s", klog.Format(obj).(logr.Marshaler).MarshalLog())
-	if strings.Index(str, "kind is config") >= 0 {
+	if strings.Contains(str, "kind is config") {
 		t.Errorf("fmt.Sprintf called TypeMeta.String for klog.Format(obj).MarshalLog():\n%s", str)
 	}
 

internal/buffer/buffer.go

@@ -36,8 +36,7 @@ var (
 // use. It also provides some helper methods for output formatting.
 type Buffer struct {
 	bytes.Buffer
-	Tmp  [64]byte // temporary byte array for creating headers.
-	next *Buffer
+	Tmp [64]byte // temporary byte array for creating headers.
 }
 
 var buffers = sync.Pool{

internal/clock/clock.go

@@ -39,16 +39,6 @@ type Clock interface {
 	// Sleep sleeps for the provided duration d.
 	// Consider making the sleep interruptible by using 'select' on a context channel and a timer channel.
 	Sleep(d time.Duration)
-	// Tick returns the channel of a new Ticker.
-	// This method does not allow to free/GC the backing ticker. Use
-	// NewTicker from WithTicker instead.
-	Tick(d time.Duration) <-chan time.Time
-}
-
-// WithTicker allows for injecting fake or real clocks into code that
-// needs to do arbitrary things based on time.
-type WithTicker interface {
-	Clock
 	// NewTicker returns a new Ticker.
 	NewTicker(time.Duration) Ticker
 }
@@ -66,7 +56,7 @@ type WithDelayedExecution interface {
 // WithTickerAndDelayedExecution allows for injecting fake or real clocks
 // into code that needs Ticker and AfterFunc functionality
 type WithTickerAndDelayedExecution interface {
-	WithTicker
+	Clock
 	// AfterFunc executes f in its own goroutine after waiting
 	// for d duration and returns a Timer whose channel can be
 	// closed by calling Stop() on the Timer.
@@ -79,7 +69,7 @@ type Ticker interface {
 	Stop()
 }
 
-var _ = WithTicker(RealClock{})
+var _ Clock = RealClock{}
 
 // RealClock really calls time.Now()
 type RealClock struct{}
@@ -115,13 +105,6 @@ func (RealClock) AfterFunc(d time.Duration, f func()) Timer {
 	}
 }
 
-// Tick is the same as time.Tick(d)
-// This method does not allow to free/GC the backing ticker. Use
-// NewTicker instead.
-func (RealClock) Tick(d time.Duration) <-chan time.Time {
-	return time.Tick(d)
-}
-
 // NewTicker returns a new Ticker.
 func (RealClock) NewTicker(d time.Duration) Ticker {
 	return &realTicker{

internal/clock/testing/fake_clock.go

@@ -25,7 +25,6 @@ import (
 
 var (
 	_ = clock.PassiveClock(&FakePassiveClock{})
-	_ = clock.WithTicker(&FakeClock{})
 	_ = clock.Clock(&IntervalClock{})
 )
 
@@ -259,36 +258,30 @@ func (i *IntervalClock) Since(ts time.Time) time.Duration {
 
 // After is unimplemented, will panic.
 // TODO: make interval clock use FakeClock so this can be implemented.
-func (*IntervalClock) After(d time.Duration) <-chan time.Time {
+func (*IntervalClock) After(time.Duration) <-chan time.Time {
 	panic("IntervalClock doesn't implement After")
 }
 
 // NewTimer is unimplemented, will panic.
 // TODO: make interval clock use FakeClock so this can be implemented.
-func (*IntervalClock) NewTimer(d time.Duration) clock.Timer {
+func (*IntervalClock) NewTimer(time.Duration) clock.Timer {
 	panic("IntervalClock doesn't implement NewTimer")
 }
 
 // AfterFunc is unimplemented, will panic.
 // TODO: make interval clock use FakeClock so this can be implemented.
-func (*IntervalClock) AfterFunc(d time.Duration, f func()) clock.Timer {
+func (*IntervalClock) AfterFunc(time.Duration, func()) clock.Timer {
 	panic("IntervalClock doesn't implement AfterFunc")
 }
 
-// Tick is unimplemented, will panic.
-// TODO: make interval clock use FakeClock so this can be implemented.
-func (*IntervalClock) Tick(d time.Duration) <-chan time.Time {
-	panic("IntervalClock doesn't implement Tick")
-}
-
 // NewTicker has no implementation yet and is omitted.
 // TODO: make interval clock use FakeClock so this can be implemented.
-func (*IntervalClock) NewTicker(d time.Duration) clock.Ticker {
+func (*IntervalClock) NewTicker(time.Duration) clock.Ticker {
 	panic("IntervalClock doesn't implement NewTicker")
 }
 
 // Sleep is unimplemented, will panic.
-func (*IntervalClock) Sleep(d time.Duration) {
+func (*IntervalClock) Sleep(time.Duration) {
 	panic("IntervalClock doesn't implement Sleep")
 }
 

internal/test/require/require.go

@@ -0,0 +1,26 @@
+/*
+Copyright 2023 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package require
+
+import "testing"
+
+func NoError(tb testing.TB, err error) {
+	if err != nil {
+		tb.Helper()
+		tb.Fatalf("Unexpected error: %v", err)
+	}
+}

internal/verbosity/verbosity.go

@@ -288,9 +288,7 @@ func (vs *VState) setV(pc uintptr) Level {
 	fn := runtime.FuncForPC(pc)
 	file, _ := fn.FileLine(pc)
 	// The file is something like /a/b/c/d.go. We want just the d.
-	if strings.HasSuffix(file, ".go") {
-		file = file[:len(file)-3]
-	}
+	file = strings.TrimSuffix(file, ".go")
 	if slash := strings.LastIndex(file, "/"); slash >= 0 {
 		file = file[slash+1:]
 	}