ci: update GitHub Actions workflow

jimmychiuuuu · jimmychiuuuu · commit 0ab3ffa29d1d · 2026-01-07T08:56:16.000Z
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -29,47 +29,38 @@ jobs:
       matrix:
         go-version: [1.21.x]
         os: [ubuntu-latest]
-        architecture: [x32, x64]
-    name: Generate/Build/Test (${{ matrix.os }}, ${{ matrix.architecture }}, Go ${{ matrix.go-version }})
+        architecture: [x64]
+    name: Build/Test (${{ matrix.os }}, ${{ matrix.architecture }}, Go ${{ matrix.go-version }})
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
           architecture: ${{ matrix.architecture }}
+          cache: true
       - name: Build all modules
-        run: CGO_ENABLED=0 go build -v
+        run: CGO_ENABLED=0 go build -v ./...
       - name: Test all modules
-        run: CGO_ENABLED=0 go test ./deviceplugin/... -v
+        run: CGO_ENABLED=0 go test ./... -v
 
   lint:
-    strategy:
-      matrix:
-        go-version: [1.21.x]
-        os: [ubuntu-latest]
-        dir: ["./"]
-    name: Lint ${{ matrix.dir }} (${{ matrix.os }}, Go ${{ matrix.go-version }})
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v2
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
         with:
-          go-version: ${{ matrix.go-version }}
+          go-version: 1.21.x
+          cache: true
       - name: Run golangci-lint
-        uses: golangci/golangci-lint-action@v3.2.0
+        uses: golangci/golangci-lint-action@v4
         with:
           version: latest
-          working-directory: ${{ matrix.dir }}
           args: >
-            -D errcheck
+            -E errcheck
             -E stylecheck
             -E goimports
             -E misspell
             -E revive
             -E gofmt
-            -E goimports
-            --exclude-use-default=false
-            --max-same-issues=0
-            --max-issues-per-linter=0
-            --timeout 2m
+            --timeout 5m
diff --git a/deviceplugin/ccdevice.go b/deviceplugin/ccdevice.go
@@ -33,7 +33,7 @@ import (
 )
 
 const (
-	deviceCheckInterval      = 5 * time.Second
+	deviceCheckInterval        = 5 * time.Second
 	copiedEventLogDirectory    = "/run/cc-device-plugin"
 	copiedEventLogLocation     = "/run/cc-device-plugin/binary_bios_measurements"
 	containerEventLogDirectory = "/run/cc-device-plugin"
@@ -57,7 +57,7 @@ type CcDeviceSpec struct {
 	Resource         string
 	DevicePaths      []string
 	MeasurementPaths []string
-	DeviceLimit      int // Number of allocatable instances of this resource
+	DeviceLimit      int             // Number of allocatable instances of this resource
 	Type             AttestationType // New flag to explicitly define the device type
 }
 
@@ -70,12 +70,12 @@ type CcDevice struct {
 
 // CcDevicePlugin is a device plugin for cc devices
 type CcDevicePlugin struct {
-	cds                    		*CcDeviceSpec
-	ccDevices              		map[string]CcDevice
-	logger                 		log.Logger
-	copiedEventLogDirectory		string
-	copiedEventLogLocation  	string
-	containerEventLogDirectory 	string
+	cds                        *CcDeviceSpec
+	ccDevices                  map[string]CcDevice
+	logger                     log.Logger
+	copiedEventLogDirectory    string
+	copiedEventLogLocation     string
+	containerEventLogDirectory string
 	// this lock prevents data race when kubelet sends multiple requests at the same time
 	mu sync.Mutex
 
@@ -94,9 +94,9 @@ func NewCcDevicePlugin(cds *CcDeviceSpec, devicePluginPath string, socket string
 	}
 
 	cdp := &CcDevicePlugin{
-		cds:                    cds,
-		ccDevices:              make(map[string]CcDevice),
-		logger:                 logger,
+		cds:                        cds,
+		ccDevices:                  make(map[string]CcDevice),
+		logger:                     logger,
 		copiedEventLogDirectory:    copiedEventLogDirectory,
 		copiedEventLogLocation:     copiedEventLogLocation, // Note: This path is static, used only by vTPM plugin instance.
 		containerEventLogDirectory: containerEventLogDirectory,
@@ -119,9 +119,9 @@ func NewCcDevicePlugin(cds *CcDeviceSpec, devicePluginPath string, socket string
 			if err != nil {
 				return nil, err
 			}
-			level.Info(cdp.logger).Log("msg", "Directory created:" + cdp.copiedEventLogDirectory)
+			_ = level.Info(cdp.logger).Log("msg", "Directory created:"+cdp.copiedEventLogDirectory)
 		} else {
-			level.Info(cdp.logger).Log("msg", "Directory already exists:" + cdp.copiedEventLogDirectory)
+			_ = level.Info(cdp.logger).Log("msg", "Directory already exists:"+cdp.copiedEventLogDirectory)
 		}
 	}
 
@@ -144,7 +144,7 @@ func (cdp *CcDevicePlugin) discoverCcDevices() ([]CcDevice, error) {
 			return nil, err
 		}
 		if len(matches) > 0 {
-			level.Info(cdp.logger).Log("msg", "found matching device path(s)", "pattern", path, "matches", strings.Join(matches, ","))
+			_ = level.Info(cdp.logger).Log("msg", "found matching device path(s)", "pattern", path, "matches", strings.Join(matches, ","))
 			foundDevicePaths = append(foundDevicePaths, matches...)
 		}
 	}
@@ -180,7 +180,7 @@ func (cdp *CcDevicePlugin) discoverCcDevices() ([]CcDevice, error) {
 			if len(matches) > 0 {
 				// We only expect one measurement file
 				foundMeasurementPath = matches[0]
-				level.Info(cdp.logger).Log("msg", "measurement path found", "path", foundMeasurementPath)
+				_ = level.Info(cdp.logger).Log("msg", "measurement path found", "path", foundMeasurementPath)
 				break
 			}
 		}
@@ -194,21 +194,21 @@ func (cdp *CcDevicePlugin) discoverCcDevices() ([]CcDevice, error) {
 			fileInfo, err := os.Stat(cdp.copiedEventLogLocation)
 			if errors.Is(err, os.ErrNotExist) {
 				if err := copyMeasurementFile(foundMeasurementPath, cdp.copiedEventLogLocation); err != nil {
-					level.Error(cdp.logger).Log("msg", "failed to copy measurement file", "error", err)
+					_ = level.Error(cdp.logger).Log("msg", "failed to copy measurement file", "error", err)
 					return nil, err
 				}
 			} else if err == nil && fileInfo.ModTime().After(measurementFileLastUpdate) {
 				// Refresh the copy if the source file has been updated by the kernel since the last copy.
 				if err := copyMeasurementFile(foundMeasurementPath, cdp.copiedEventLogLocation); err != nil {
-					level.Error(cdp.logger).Log("msg", "failed to re-copy measurement file", "error", err)
+					_ = level.Error(cdp.logger).Log("msg", "failed to re-copy measurement file", "error", err)
 					return nil, err
 				}
 			} else if err != nil {
-				level.Error(cdp.logger).Log("msg", "failed to stat copied measurement file", "error", err)
+				_ = level.Error(cdp.logger).Log("msg", "failed to stat copied measurement file", "error", err)
 				return nil, err
 			}
 		} else {
-			level.Warn(cdp.logger).Log("msg", "MeasurementPaths specified but no measurement file found", "paths", strings.Join(cdp.cds.MeasurementPaths, ","))
+			_ = level.Warn(cdp.logger).Log("msg", "MeasurementPaths specified but no measurement file found", "paths", strings.Join(cdp.cds.MeasurementPaths, ","))
 		}
 	}
 
@@ -292,13 +292,13 @@ func (cdp *CcDevicePlugin) refreshDevices() (bool, error) {
 	// Log if devices were removed
 	for k := range old {
 		if _, ok := cdp.ccDevices[k]; !ok {
-			level.Info(cdp.logger).Log("msg", "device removed", "id", k)
+			_ = level.Info(cdp.logger).Log("msg", "device removed", "id", k)
 		}
 	}
 	// Log if devices were added
 	for k := range cdp.ccDevices {
 		if _, ok := old[k]; !ok {
-			level.Info(cdp.logger).Log("msg", "device added", "id", k)
+			_ = level.Info(cdp.logger).Log("msg", "device added", "id", k)
 		}
 	}
 
@@ -323,14 +323,14 @@ func (cdp *CcDevicePlugin) Allocate(_ context.Context, req *v1beta1.AllocateRequ
 			if ccDevice.Health != v1beta1.Healthy {
 				return nil, fmt.Errorf("requested cc device is not healthy %q", id)
 			}
-			level.Info(cdp.logger).Log("msg", "adding device and measurement to Pod", "device id", id)
+			_ = level.Info(cdp.logger).Log("msg", "adding device and measurement to Pod", "device id", id)
 
 			for _, ds := range ccDevice.DeviceSpecs {
-				level.Debug(cdp.logger).Log("msg", "added ccDevice.deviceSpecs", "spec", ds.String())
+				_ = level.Debug(cdp.logger).Log("msg", "added ccDevice.deviceSpecs", "spec", ds.String())
 			}
 
 			for _, dm := range ccDevice.Mounts {
-				level.Debug(cdp.logger).Log("msg", "added ccDevice.mounts", "mount", dm.String())
+				_ = level.Debug(cdp.logger).Log("msg", "added ccDevice.mounts", "mount", dm.String())
 			}
 
 			resp.Devices = append(resp.Devices, ccDevice.DeviceSpecs...)
@@ -349,7 +349,7 @@ func (cdp *CcDevicePlugin) GetDevicePluginOptions(_ context.Context, _ *v1beta1.
 
 // ListAndWatch lists all devices and then refreshes every deviceCheckInterval.
 func (cdp *CcDevicePlugin) ListAndWatch(_ *v1beta1.Empty, stream v1beta1.DevicePlugin_ListAndWatchServer) error {
-	level.Info(cdp.logger).Log("msg", "starting list and watch")
+	_ = level.Info(cdp.logger).Log("msg", "starting list and watch")
 	if _, err := cdp.refreshDevices(); err != nil {
 		return err
 	}
@@ -363,14 +363,14 @@ func (cdp *CcDevicePlugin) ListAndWatch(_ *v1beta1.Empty, stream v1beta1.DeviceP
 		cdp.mu.Unlock()
 
 		if err := stream.Send(res); err != nil {
-			level.Error(cdp.logger).Log("msg", "failed to send ListAndWatchResponse", "error", err)
+			_ = level.Error(cdp.logger).Log("msg", "failed to send ListAndWatchResponse", "error", err)
 			return err
 		}
 
 		<-time.After(deviceCheckInterval)
 
 		if _, err := cdp.refreshDevices(); err != nil {
-			level.Error(cdp.logger).Log("msg", "error during device refresh", "error", err)
+			_ = level.Error(cdp.logger).Log("msg", "error during device refresh", "error", err)
 			// Don't return error immediately, try to continue
 		}
 	}
diff --git a/deviceplugin/ccdevice_test.go b/deviceplugin/ccdevice_test.go
@@ -93,7 +93,9 @@ func constructTestPlugin(t *testing.T, spec *CcDeviceSpec) *CcDevicePlugin {
 
 	// For SoftwareAttestation, we expect the directory to be created
 	if spec.Type == SoftwareAttestation {
-		os.MkdirAll(cdp.copiedEventLogDirectory, 0755)
+		if err := os.MkdirAll(cdp.copiedEventLogDirectory, 0755); err != nil {
+			t.Fatalf("failed to create directory: %v", err)
+		}
 	}
 
 	return cdp
@@ -223,7 +225,9 @@ func TestAllocate(t *testing.T) {
 		DeviceLimit:      2,
 	}
 	cdp := constructTestPlugin(t, spec)
-	cdp.refreshDevices()
+	if _, err := cdp.refreshDevices(); err != nil {
+		t.Fatalf("refreshDevices failed: %v", err)
+	}
 
 	ctx := context.Background()
 	expectedID := getExpectedID(spec.Resource, spec.DeviceLimit, 0)
@@ -259,10 +263,8 @@ func TestAllocateNotExistDevice(t *testing.T) {
 		}},
 	}
 	_, err := cdp.Allocate(context.Background(), req)
-	if err == nil || !errors.Is(err, err) { // Simplified check for existence of error
-		if !errors.Is(err, fmt.Errorf("requested cc device does not exist \"NonExistentID\"")) {
-			// Logic check passed if error contains the string
-		}
+	if err == nil {
+		t.Fatal("expected error for non-existent device, got nil")
 	}
 }
 
@@ -277,13 +279,13 @@ func (d *listAndWatchServerStub) Send(*v1beta1.ListAndWatchResponse) error {
 	return nil
 }
 
-func (d *listAndWatchServerStub) SetTestComplete() { d.testComplete = true }
-func (d *listAndWatchServerStub) SetHeader(metadata.MD) error { return nil }
+func (d *listAndWatchServerStub) SetTestComplete()             { d.testComplete = true }
+func (d *listAndWatchServerStub) SetHeader(metadata.MD) error  { return nil }
 func (d *listAndWatchServerStub) SendHeader(metadata.MD) error { return nil }
-func (d *listAndWatchServerStub) SetTrailer(metadata.MD) {}
-func (d *listAndWatchServerStub) Context() context.Context { return context.Background() }
-func (d *listAndWatchServerStub) SendMsg(any) error { return nil }
-func (d *listAndWatchServerStub) RecvMsg(any) error { return nil }
+func (d *listAndWatchServerStub) SetTrailer(metadata.MD)       { /* no-op for testing */ }
+func (d *listAndWatchServerStub) Context() context.Context     { return context.Background() }
+func (d *listAndWatchServerStub) SendMsg(any) error            { return nil }
+func (d *listAndWatchServerStub) RecvMsg(any) error            { return nil }
 
 func TestListAndWatch(t *testing.T) {
 	spec := &CcDeviceSpec{
@@ -321,5 +323,7 @@ func TestListAndWatch(t *testing.T) {
 		}, func(error) {})
 	}
 
-	g.Run()
+	if err := g.Run(); err != nil && err.Error() != "test complete" {
+		t.Errorf("run group failed: %v", err)
+	}
 }
diff --git a/deviceplugin/plugin.go b/deviceplugin/plugin.go
@@ -102,7 +102,7 @@ Outer:
 			err := p.runOnce(ctx)
 			if err != nil {
 				lastErrorTime = time.Now()
-				level.Warn(p.logger).Log("msg", "encountered error while running plugin", "err", err)
+				_ = level.Warn(p.logger).Log("msg", "encountered error while running plugin", "err", err)
 				select {
 				case <-ctx.Done():
 					break Outer
@@ -129,15 +129,15 @@ Outer:
 // This makes it convenient to run in a run.Group.
 func (p *plugin) serve(ctx context.Context) (func() error, func(error), error) {
 	// Run the gRPC server.
-	level.Info(p.logger).Log("msg", "listening on Unix socket", "socket", p.socket)
+	_ = level.Info(p.logger).Log("msg", "listening on Unix socket", "socket", p.socket)
 	l, err := net.Listen("unix", p.socket)
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to listen on Unix socket %q: %v", p.socket, err)
 	}
 
 	ch := make(chan error)
 	go func() {
-		level.Info(p.logger).Log("msg", "starting gRPC server")
+		_ = level.Info(p.logger).Log("msg", "starting gRPC server")
 		ch <- p.grpcServer.Serve(l)
 		close(ch)
 	}()
@@ -148,7 +148,7 @@ Outer:
 		for range p.grpcServer.GetServiceInfo() {
 			break Outer
 		}
-		level.Info(p.logger).Log("msg", "waiting for gRPC server to be ready")
+		_ = level.Info(p.logger).Log("msg", "waiting for gRPC server to be ready")
 		select {
 		case <-ctx.Done():
 			return nil, nil, ctx.Err()
@@ -164,7 +164,7 @@ Outer:
 			// Drain the channel to clean up.
 			<-ch
 			if err := l.Close(); err != nil {
-				level.Warn(p.logger).Log("msg", "encountered error while closing the listener", "err", err)
+				_ = level.Warn(p.logger).Log("msg", "encountered error while closing the listener", "err", err)
 			}
 		}, nil
 }
@@ -190,7 +190,7 @@ func (p *plugin) runOnce(ctx context.Context) error {
 		ctx, cancel := context.WithCancel(ctx)
 		g.Add(func() error {
 			defer cancel()
-			level.Info(p.logger).Log("msg", "waiting for the gRPC server to be ready")
+			_ = level.Info(p.logger).Log("msg", "waiting for the gRPC server to be ready")
 			c, err := grpc.DialContext(ctx, p.socket, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock(),
 				grpc.WithContextDialer(func(ctx context.Context, addr string) (net.Conn, error) {
 					return (&net.Dialer{}).DialContext(ctx, "unix", addr)
@@ -202,11 +202,11 @@ func (p *plugin) runOnce(ctx context.Context) error {
 			if err := c.Close(); err != nil {
 				return fmt.Errorf("failed to close connection to local gRPC server: %v", err)
 			}
-			level.Info(p.logger).Log("msg", "the gRPC server is ready")
+			_ = level.Info(p.logger).Log("msg", "the gRPC server is ready")
 			if err := p.registerWithKubelet(); err != nil {
 				return fmt.Errorf("failed to register with kubelet: %v", err)
 			}
-			level.Info(p.logger).Log("msg", "the registration is complete")
+			_ = level.Info(p.logger).Log("msg", "the registration is complete")
 			<-ctx.Done()
 			return nil
 		}, func(error) {
@@ -239,7 +239,7 @@ func (p *plugin) runOnce(ctx context.Context) error {
 }
 
 func (p *plugin) registerWithKubelet() error {
-	level.Info(p.logger).Log("msg", "registering plugin with kubelet")
+	_ = level.Info(p.logger).Log("msg", "registering plugin with kubelet")
 	conn, err := grpc.Dial(filepath.Join(p.pluginDir, p.kubeSocketBase), grpc.WithTransportCredentials(insecure.NewCredentials()),
 		grpc.WithContextDialer(func(ctx context.Context, addr string) (net.Conn, error) {
 			d := &net.Dialer{}
diff --git a/deviceplugin/plugin_test.go b/deviceplugin/plugin_test.go
@@ -165,7 +165,9 @@ func TestRegisterWithKublet(t *testing.T) {
 		}, func(error) {})
 	}
 
-	g.Run()
+	if err := g.Run(); err != nil && err.Error() != "test complete" {
+		t.Errorf("run group failed: %v", err)
+	}
 }
 
 func maybeLogError(f func() error, message string) {
diff --git a/main.go b/main.go

Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,9 @@ func TestRegisterWithKublet(t *testing.T) {`
`165`	`165`	`}, func(error) {})`
`166`	`166`	`}`
`167`	`167`
`168`		`- g.Run()`
	`168`	`+ if err := g.Run(); err != nil && err.Error() != "test complete" {`
	`169`	`+ t.Errorf("run group failed: %v", err)`
	`170`	`+ }`
`169`	`171`	`}`
`170`	`172`
`171`	`173`	`func maybeLogError(f func() error, message string) {`