fix(resourcetopo): fix lint issues — misspell 'cancelled'→'canceled', shadow builtin 'min', and gofmt formatting

Co-Authored-By: Claude <noreply@anthropic.com>

Author: AnnaYue

resourcetopo/doc.go

@@ -18,7 +18,7 @@
 // resources. It maintains relationships between different resource types and notifies
 // handlers when resources or their relationships change.
 //
-// Lock Hierarchy
+// # Lock Hierarchy
 //
 // To prevent deadlocks, locks must be acquired in the following order:
 //
@@ -50,55 +50,54 @@
 //   - Protects: nodeUpdateHandler, relationUpdateHandler
 //   - Independent - can be acquired anytime
 //
-// Threading Model
+// # Threading Model
 //
 // This package uses multiple goroutines for concurrent processing. Understanding the
 // threading model is essential for avoiding race conditions and deadlocks.
 //
 // 1. Informer Threads (External):
-//    - Source: Kubernetes informers (one per resource type)
-//    - Entry points: nodeStorage.OnAdd, OnUpdate, OnDelete
-//    - Purpose: Receives resource change events from API server
-//    - Lock behavior: Acquires metaLock.Lock() during updateNodeMeta(), relationsLock during relation updates
-//    - Note: These are the ONLY threads that write to metaLock (labels, ownerRefs, objectExisted)
+//   - Source: Kubernetes informers (one per resource type)
+//   - Entry points: nodeStorage.OnAdd, OnUpdate, OnDelete
+//   - Purpose: Receives resource change events from API server
+//   - Lock behavior: Acquires metaLock.Lock() during updateNodeMeta(), relationsLock during relation updates
+//   - Note: These are the ONLY threads that write to metaLock (labels, ownerRefs, objectExisted)
 //
 // 2. Event Processor Threads (Internal):
-//    - Source: Created by Start() -> startHandleEvent()
-//    - Count: 2 goroutines
-//      - handleNodeEvent(): Processes node add/update/delete/relatedUpdate events
-//      - handleRelationEvent(): Processes relation add/delete events
-//    - Trigger: newNodeEvent(), newRelationEvent() queue events via workqueue
-//    - Lock behavior: Read-only access to handlers via RLock, no direct node locking
-//    - Note: Reads handlers while holding no locks - relies on handlersLock for registration
+//   - Source: Created by Start() -> startHandleEvent()
+//   - Count: 2 goroutines
+//   - handleNodeEvent(): Processes node add/update/delete/relatedUpdate events
+//   - handleRelationEvent(): Processes relation add/delete events
+//   - Trigger: newNodeEvent(), newRelationEvent() queue events via workqueue
+//   - Lock behavior: Read-only access to handlers via RLock, no direct node locking
+//   - Note: Reads handlers while holding no locks - relies on handlersLock for registration
 //
 // 3. User/Client Threads (External):
-//    - Source: User code calling Manager methods
-//    - Examples: GetNode(), GetTopoNodeStorage(), AddNodeHandler()
-//    - Lock behavior: Uses storagesLock.RLock() for reads
-//    - Note: These are typically short-lived operations
+//   - Source: User code calling Manager methods
+//   - Examples: GetNode(), GetTopoNodeStorage(), AddNodeHandler()
+//   - Lock behavior: Uses storagesLock.RLock() for reads
+//   - Note: These are typically short-lived operations
 //
 // 4. Callback Threads (External - via Event Processors):
-//    - Source: User-provided NodeHandler and RelationHandler callbacks
-//    - Entry: Called by handleNodeEvent/handleRelationEvent
-//    - Execution: Each callback runs in its own goroutine with a configurable timeout
-//      (ManagerConfig.EventHandlerTimeout, default 1s). If a callback does not return
-//      within the timeout, a warning is logged and all remaining handlers for that
-//      event are skipped.
-//    - Lock behavior: No resourcetopo locks held during callback execution
-//    - Concurrency: Multiple callbacks (across different handlers or events) may run
-//      concurrently. Handler implementations that share mutable state must be
-//      thread-safe.
-//    - Safety: Handlers receive node references but should not cache them long-term
-//
-// Thread Safety Guidelines
-//
-// - NodeInfo references returned by GetNode() are safe for concurrent reads
-// - Do NOT call AddTopologyConfig() after Start() - not thread safe
-// - Handler registration (AddNodeHandler, AddRelationHandler) is thread safe
-// - Callbacks (OnAdd, OnUpdate, etc.) run in goroutines with a timeout.
-//   Do not block indefinitely — timed-out callbacks cause remaining handlers
-//   to be skipped. Implementations must be thread-safe if they share state.
-// - nodeInfo.lock can be held for extended periods during relation changes
-// - metaLock is never held during callbacks or cross-node operations
-//
+//   - Source: User-provided NodeHandler and RelationHandler callbacks
+//   - Entry: Called by handleNodeEvent/handleRelationEvent
+//   - Execution: Each callback runs in its own goroutine with a configurable timeout
+//     (ManagerConfig.EventHandlerTimeout, default 1s). If a callback does not return
+//     within the timeout, a warning is logged and all remaining handlers for that
+//     event are skipped.
+//   - Lock behavior: No resourcetopo locks held during callback execution
+//   - Concurrency: Multiple callbacks (across different handlers or events) may run
+//     concurrently. Handler implementations that share mutable state must be
+//     thread-safe.
+//   - Safety: Handlers receive node references but should not cache them long-term
+//
+// # Thread Safety Guidelines
+//
+//   - NodeInfo references returned by GetNode() are safe for concurrent reads
+//   - Do NOT call AddTopologyConfig() after Start() - not thread safe
+//   - Handler registration (AddNodeHandler, AddRelationHandler) is thread safe
+//   - Callbacks (OnAdd, OnUpdate, etc.) run in goroutines with a timeout.
+//     Do not block indefinitely — timed-out callbacks cause remaining handlers
+//     to be skipped. Implementations must be thread-safe if they share state.
+//   - nodeInfo.lock can be held for extended periods during relation changes
+//   - metaLock is never held during callbacks or cross-node operations
 package resourcetopo

resourcetopo/resourcetopo_test.go

@@ -19,6 +19,7 @@ package resourcetopo
 import (
 	"context"
 	"fmt"
+	"runtime"
 	"sync"
 	"testing"
 	"time"
@@ -30,7 +31,6 @@ import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/informers"
 	"k8s.io/client-go/kubernetes/fake"
-	"runtime"
 	"k8s.io/klog/v2"
 )
 
@@ -2023,8 +2023,8 @@ var _ = Describe("test suite for multi routine", func() {
 				g.Expect(len(rsNode.GetPostOrders())).To(Equal(totalNum / len(rsNames)))
 			}
 		}, "10s").Should(Succeed())
-		})
 	})
+})
 
 var _ = Describe("test handler timeout protection", func() {
 	var manager Manager
@@ -2127,18 +2127,21 @@ func (h *blockingNodeHandler) OnAdd(ctx context.Context, info NodeInfo) {
 	case <-ctx.Done():
 	}
 }
+
 func (h *blockingNodeHandler) OnUpdate(ctx context.Context, info NodeInfo) {
 	select {
 	case <-h.blockCh:
 	case <-ctx.Done():
 	}
 }
+
 func (h *blockingNodeHandler) OnDelete(ctx context.Context, info NodeInfo) {
 	select {
 	case <-h.blockCh:
 	case <-ctx.Done():
 	}
 }
+
 func (h *blockingNodeHandler) OnRelatedUpdate(ctx context.Context, info NodeInfo) {
 	select {
 	case <-h.blockCh:
@@ -2159,6 +2162,7 @@ func (h *blockingRelationHandler) OnAdd(ctx context.Context, preNode, postNode N
 	case <-ctx.Done():
 	}
 }
+
 func (h *blockingRelationHandler) OnDelete(ctx context.Context, preNode, postNode NodeInfo) {
 	select {
 	case <-h.blockCh:
@@ -2441,7 +2445,7 @@ var _ = Describe("test goroutine leak and panic handling", func() {
 		crName := "crNoLeak"
 
 		// Register a cooperative blocking handler for ClusterRole
-		// (selects on ctx.Done() so it returns when context is cancelled)
+		// (selects on ctx.Done() so it returns when context is canceled)
 		blockCh := make(chan struct{})
 		blockingHandler := &blockingNodeHandler{blockCh: blockCh}
 		Expect(manager.AddNodeHandler(ClusterRoleMeta, blockingHandler)).To(Succeed())
@@ -2458,7 +2462,7 @@ var _ = Describe("test goroutine leak and panic handling", func() {
 		// Count baseline goroutines
 		baseline := countStableGoroutines(3, 100*time.Millisecond)
 
-		// Trigger handler — ctx will be cancelled after timeout, handler returns
+		// Trigger handler — ctx will be canceled after timeout, handler returns
 		Expect(fakeClient.RbacV1().ClusterRoles().Create(ctx, newClusterRole(crName), metav1.CreateOptions{})).NotTo(BeNil())
 
 		// Wait well past timeout for handler to return and goroutine to exit
@@ -2512,24 +2516,35 @@ var _ = Describe("test goroutine leak and panic handling", func() {
 // countStableGoroutines samples NumGoroutine multiple times and returns
 // the minimum observed count (to filter out transient goroutines).
 func countStableGoroutines(samples int, interval time.Duration) int {
-	min := runtime.NumGoroutine()
+	minGoroutines := runtime.NumGoroutine()
 	for i := 1; i < samples; i++ {
 		time.Sleep(interval)
 		n := runtime.NumGoroutine()
-		if n < min {
-			min = n
+		if n < minGoroutines {
+			minGoroutines = n
 		}
 	}
-	return min
+	return minGoroutines
 }
 
 // panickingNodeHandler panics on every callback, used to test panic absorption.
 type panickingNodeHandler struct{}
 
-func (h *panickingNodeHandler) OnAdd(ctx context.Context, info NodeInfo)              { panic("intentional panic in OnAdd") }
-func (h *panickingNodeHandler) OnUpdate(ctx context.Context, info NodeInfo)           { panic("intentional panic in OnUpdate") }
-func (h *panickingNodeHandler) OnDelete(ctx context.Context, info NodeInfo)           { panic("intentional panic in OnDelete") }
-func (h *panickingNodeHandler) OnRelatedUpdate(ctx context.Context, info NodeInfo)    { panic("intentional panic in OnRelatedUpdate") }
+func (h *panickingNodeHandler) OnAdd(ctx context.Context, info NodeInfo) {
+	panic("intentional panic in OnAdd")
+}
+
+func (h *panickingNodeHandler) OnUpdate(ctx context.Context, info NodeInfo) {
+	panic("intentional panic in OnUpdate")
+}
+
+func (h *panickingNodeHandler) OnDelete(ctx context.Context, info NodeInfo) {
+	panic("intentional panic in OnDelete")
+}
+
+func (h *panickingNodeHandler) OnRelatedUpdate(ctx context.Context, info NodeInfo) {
+	panic("intentional panic in OnRelatedUpdate")
+}
 
 var _ NodeHandler = &panickingNodeHandler{}
 

resourcetopo/types.go

@@ -52,7 +52,7 @@ type ManagerConfig struct {
 	RelationEventHandleRateMaxDelay time.Duration
 
 	// EventHandlerTimeout is the timeout for each event handler callback.
-	// If a handler takes longer than this timeout, it will be cancelled and
+	// If a handler takes longer than this timeout, it will be canceled and
 	// remaining handlers will be skipped. A warning will be logged.
 	// Default: 1 second
 	EventHandlerTimeout time.Duration
@@ -176,30 +176,30 @@ type ResourceRelation struct {
 
 type RelationHandler interface {
 	// OnAdd is called after relation newly added between preOrder and postOrder.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnAdd(ctx context.Context, preOrder, postOrder NodeInfo)
 
 	// OnDelete is called after relation deleted between preOrder and postOrder.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnDelete(ctx context.Context, preOrder, postOrder NodeInfo)
 }
 
 type NodeHandler interface {
 	// OnAdd is called when the node related resource object is added.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnAdd(ctx context.Context, info NodeInfo)
 
 	// OnUpdate is called when the node related resource object is updated.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnUpdate(ctx context.Context, info NodeInfo)
 
 	// OnDelete is called when the node related resource object is deleted.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnDelete(ctx context.Context, info NodeInfo)
 
 	// OnRelatedUpdate is called when the nodes'
 	// post-order(or pre-order if ReverseNotice configured) object is updated.
-	// The ctx is cancelled when the handler exceeds EventHandlerTimeout.
+	// The ctx is canceled when the handler exceeds EventHandlerTimeout.
 	OnRelatedUpdate(ctx context.Context, info NodeInfo)
 }