ccx-agentic-223

I'll search for the major kubelet components in the Kubernetes repository. Let me start by loading the Sourcegraph tools and then searching for each component.

{"matches": ["mcp__sourcegraph__sg_keyword_search", "mcp__sourcegraph__sg_list_files", "mcp__sourcegraph__sg_read_file", "mcp__sourcegraph__sg_nls_search"], "query": "select:mcp__sourcegraph__sg_keyword_search,mcp__sourcegraph__sg_list_files,mcp__sourcegraph__sg_read_file,mcp__sourcegraph__sg_nls_search", "total_deferred_tools": 33}

Now I'll search for all four kubelet components in parallel.

{"text":"No results.\n\nNo results found."}

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/volumemanager/volume_manager_fake.go\n16: \n17: package volumemanager\n18: \n19: \n28: \n29: // FakeVolumeManager is a test implementation that just tracks calls\n30: type FakeVolumeManager struct {\n31: \tvolumes       map[v1.UniqueVolumeName]bool\n32: \n36: \n37: var _ VolumeManager = &FakeVolumeManager{}\n38: \n39: // NewFakeVolumeManager creates a new VolumeManager test instance\n40: func NewFakeVolumeManager(initialVolumes []v1.UniqueVolumeName, unmountDelay time.Duration, unmountError error) *FakeVolumeManager {\n41: \tvolumes := map[v1.UniqueVolumeName]bool{}\n42: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/volumemanager/metrics/metrics.go\n32: \t// Metric keys for Volume Manager.\n33: \tvolumeManagerTotalVolumes                     = \"volume_manager_total_volumes\"\n34: \treconstructVolumeOperationsTotal              = \"reconstruct_volume_operations_total\"\n35: \n43: \ttotalVolumesDesc = metrics.NewDesc(\n44: \t\tvolumeManagerTotalVolumes,\n45: \t\t\"Number of volumes in Volume Manager\",\n46: \n23: \t\"k8s.io/component-base/metrics/legacyregistry\"\n24: \t\"k8s.io/kubernetes/pkg/kubelet/volumemanager/cache\"\n25: \t\"k8s.io/kubernetes/pkg/volume\"\n26: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/volumemanager/volume_manager.go\n16: \n17: package volumemanager\n18: \n19: \n180: // Must be pre-initialized.\n181: func NewVolumeManager(\n182: \tcontrollerAttachDetachEnabled bool,\n183: \n241: \n242: // volumeManager implements the VolumeManager interface\n243: type volumeManager struct {\n244: \t// kubeClient is the kube API client used by DesiredStateOfWorldPopulator to\n245: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/volumemanager/OWNERS\n\n# githu...

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/cm/devicemanager/plugin/v1beta1/api.go\n37: const (\n38: \t// errFailedToDialDevicePlugin is the error raised when the device plugin could not be\n39: \t// reached on the registered socket\n40: \terrFailedToDialDevicePlugin = \"failed to dial device plugin:\"\n41: \t// errUnsupportedVersion is the error raised when the device plugin uses an API version not\n42: \n30: type ClientHandler interface {\n31: \tPluginConnected(string, DevicePlugin) error\n32: \tPluginDisconnected(string)\n33: \n19: import (\n20: \tapi \"k8s.io/kubelet/pkg/apis/deviceplugin/v1beta1\"\n21: )\n22: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/cm/devicemanager/plugin/v1beta1/client.go\n32: \n33: // DevicePlugin interface provides methods for accessing Device Plugin resources, API and unix socket.\n34: type DevicePlugin interface {\n35: \tAPI() api.DevicePluginClient\n36: \tResource() string\n37: \n52: \thandler  ClientHandler\n53: \tclient   api.DevicePluginClient\n54: }\n55: \n141: \n142: \treturn api.NewDevicePluginClient(c), c, nil\n143: }\n144: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/pluginmanager/pluginwatcher/README.md\n32: During plugin initialization phase, Kubelet will issue Plugin specific calls\n33: (e.g: DevicePlugin::GetDevicePluginOptions).\n34: \n35: \n51: - The plugin name sent during Registration.GetInfo grpc should be unique\n52:   for the given plugin type (CSIPlugin or DevicePlugin).\n53: \n54: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/cm/container_manager_stub.go\n102: \n103: func (cm *containerManagerStub) GetDevicePluginResourceCapacity() (v1.ResourceList, v1.ResourceList, []string) {\n104: \treturn cm.extendedPluginResources, cm.extendedPluginResources, []str...

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/apis/config/types.go\n556: \n557: // KubeletX509Authentication contains settings related to x509 client certificate authentication\n558: type KubeletX509Authentication struct {\n559: \t// clientCAFile is the path to a PEM-encoded certificate bundle. If set, any request presenting a client certificate\n560: \t// signed by one of the authorities in the bundle is authenticated with a username corresponding to the CommonName,\n561: \t// and groups corresponding to the Organization in the client certificate.\n562: \tClientCAFile string\n563: }\n564: \n495: \t// Examples:'unix:///path/to/runtime.sock', 'npipe:////./pipe/runtime'\n496: \tContainerRuntimeEndpoint string\n497: \n498: \n428: \t// +optional\n429: \tShutdownGracePeriodCriticalPods metav1.Duration\n430: \t// ShutdownGracePeriodByPodPriority specifies the shutdown grace period for Pods based\n431: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/cm/container_manager.go\n169: \tKubeletOOMScoreAdj    int32\n170: \tContainerRuntime      string\n171: \tCgroupsPerQOS         bool\n172: \n32: \t\"k8s.io/apiserver/pkg/server/healthz\"\n33: \tinternalapi \"k8s.io/cri-api/pkg/apis\"\n34: \tpodresourcesapi \"k8s.io/kubelet/pkg/apis/podresources/v1\"\n35: \n257: \t\t\t\t// This is legal, so we report the devices anyway,\n258: \t\t\t\t// let the client decide what to do.\n259: \t\t\t\trespDevs = append(respDevs, &podresourcesapi.ContainerDevices{\n260: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kubelet.go\n70: \t\"k8s.io/component-helpers/apimachinery/lease\"\n71: \tinternalapi \"k8s.io/cri-api/pkg/apis\"\n72: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n73: \tremote \"k8s.io/cri-client/pkg\"\n74: \t\"k8s.io/klog/v2\"\n75: \n3139...

Let me now search more specifically for each component's main implementation files.

{"text":"pkg/kubelet/lifecycle/admission_failure_handler_stub.go\npkg/kubelet/lifecycle/doc.go\npkg/kubelet/lifecycle/handlers.go\npkg/kubelet/lifecycle/handlers_test.go\npkg/kubelet/lifecycle/interfaces.go\npkg/kubelet/lifecycle/predicate.go\npkg/kubelet/lifecycle/predicate_test.go\n"}

{"text":"pkg/kubelet/cm/devicemanager/checkpoint/\npkg/kubelet/cm/devicemanager/plugin/\npkg/kubelet/cm/devicemanager/OWNERS\npkg/kubelet/cm/devicemanager/endpoint.go\npkg/kubelet/cm/devicemanager/endpoint_test.go\npkg/kubelet/cm/devicemanager/manager.go\npkg/kubelet/cm/devicemanager/manager_test.go\npkg/kubelet/cm/devicemanager/pod_devices.go\npkg/kubelet/cm/devicemanager/pod_devices_test.go\npkg/kubelet/cm/devicemanager/topology_hints.go\npkg/kubelet/cm/devicemanager/topology_hints_test.go\npkg/kubelet/cm/devicemanager/types.go\n"}

{"text":"pkg/kubelet/volumemanager/cache/\npkg/kubelet/volumemanager/metrics/\npkg/kubelet/volumemanager/populator/\npkg/kubelet/volumemanager/reconciler/\npkg/kubelet/volumemanager/OWNERS\npkg/kubelet/volumemanager/volume_manager.go\npkg/kubelet/volumemanager/volume_manager_fake.go\npkg/kubelet/volumemanager/volume_manager_test.go\n"}

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/kuberuntime_manager.go\n97: \n98: type kubeGenericRuntimeManager struct {\n99: \truntimeName string\n100: \n187: \n188: // NewKubeGenericRuntimeManager creates a new kubeGenericRuntimeManager\n189: func NewKubeGenericRuntimeManager(\n190: \trecorder record.EventRecorder,\n191: \n226: \ttracer := tracerProvider.Tracer(instrumentationScope)\n227: \tkubeRuntimeManager := &kubeGenericRuntimeManager{\n228: \t\trecorder:               recorder,\n229: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/helpers.go\n91: // toKubeContainer converts runtimeapi.Container to kubecontainer.Container.\n92: func (m *kubeGenericRuntimeManager) toKubeContainer(c *runtimeapi.Container) (*kubecontainer.Container, error) {\n93: \tif c == nil || c.Id == \"\" || c.Image == nil {\n94: \n119: // TODO: Remove this once it becomes obsolete.\n120: func (m *kubeGenericRuntimeManager) sandboxToKubeContainer(s *runtimeapi.PodSandbox) (*kubecontainer.Container, error) {\n121: \tif s == nil || s.Id == \"\" {\n122: \n132: // guarantees that only one of them is set.\n133: func (m *kubeGenericRuntimeManager) getImageUser(ctx context.Context, image string) (*int64, string, error) {\n134: \tresp, err := m.imageService.ImageStatus(ctx, &runtimeapi.ImageSpec{Image: image}, false)\n135: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/kuberuntime_gc.go\n39: \tclient           internalapi.RuntimeService\n40: \tmanager          *kubeGenericRuntimeManager\n41: \tpodStateProvider podStateProvider\n42: \n45: // NewContainerGC creates a new containerGC.\n46: func newContainerGC(client internalapi.RuntimeService, podStateProvider podStateProvider, manager *kubeGenericRuntimeManager, tracer trace.Tra...

Let me search for more specific files - pod lifecycle (PLEG) and CRI client.

{"text":"pkg/kubelet/pleg/doc.go\npkg/kubelet/pleg/evented.go\npkg/kubelet/pleg/evented_test.go\npkg/kubelet/pleg/generic.go\npkg/kubelet/pleg/generic_test.go\npkg/kubelet/pleg/pleg.go\n"}

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/pod_workers.go\n599: \n600: func newPodWorkers(\n601: \tpodSyncer podSyncer,\n602: \n91: // teardown of containers (terminating), or cleanup (terminated).\n92: type PodWorkerState int\n93: \n94: \n550: // in the pod status change).\n551: type podWorkers struct {\n552: \t// Protects all per worker fields.\n553: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/metrics/metrics.go\n42: \tNodeStartupKey                     = \"node_startup_duration_seconds\"\n43: \tPodWorkerDurationKey               = \"pod_worker_duration_seconds\"\n44: \tPodStartDurationKey                = \"pod_start_duration_seconds\"\n45: \n47: \tCgroupManagerOperationsKey         = \"cgroup_manager_duration_seconds\"\n48: \tPodWorkerStartDurationKey          = \"pod_worker_start_duration_seconds\"\n49: \tPodStatusSyncDurationKey           = \"pod_status_sync_duration_seconds\"\n50: \n208: \t)\n209: \t// PodWorkerDuration is a Histogram that tracks the duration (in seconds) in takes to sync a single pod.\n210: \t// Broken down by the operation type.\n211: \tPodWorkerDuration = metrics.NewHistogramVec(\n212: \t\t&metrics.HistogramOpts{\n213: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/pod_workers_test.go\n42: \n43: // fakePodWorkers runs sync pod function in serial, so we can have\n44: // deterministic behaviour in testing.\n45: type fakePodWorkers struct {\n46: \tlock      sync.Mutex\n47: \n1928: \n1929: // TestFakePodWorkers verifies that the fakePodWorkers behaves the same way as the real podWorkers\n1930: // for their invocation of the syncPodFn.\n1931: func TestFakePodWorkers(t *testing.T) {\n1932: \tfakeRecorder := &record.FakeRecorder{}\n1933: \n390: \n391: func createPodWorkers() (*podWorkers, *containert...

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/instrumented_services.go\n27: \n28: // instrumentedRuntimeService wraps the RuntimeService and records the operations\n29: // and errors metrics.\n30: type instrumentedRuntimeService struct {\n31: \tservice internalapi.RuntimeService\n32: }\n33: \n38: \n39: // instrumentedImageManagerService wraps the ImageManagerService and records the operations\n40: // and errors metrics.\n41: type instrumentedImageManagerService struct {\n42: \tservice internalapi.ImageManagerService\n43: }\n44: \n33: \n34: // Creates an instrumented RuntimeInterface from an existing RuntimeService.\n35: func newInstrumentedRuntimeService(service internalapi.RuntimeService) internalapi.RuntimeService {\n36: \treturn &instrumentedRuntimeService{service: service}\n37: }\n38: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/fake_kuberuntime_manager.go\n111: \t\truntimeHelper:          runtimeHelper,\n112: \t\truntimeService:         runtimeService,\n113: \t\timageService:           imageService,\n114: \n95: \n96: func newFakeKubeRuntimeManager(runtimeService internalapi.RuntimeService, imageService internalapi.ImageManagerService, machineInfo *cadvisorapi.MachineInfo, osInterface kubecontainer.OSInterface, runtimeHelper kubecontainer.RuntimeHelper, keyring credenti ... [line truncated]\n97: \tctx := context.Background()\n98: \n122: \n123: \ttypedVersion, err := runtimeService.Version(ctx, kubeRuntimeAPIVersion)\n124: \tif err != nil {\n125: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kuberuntime/kuberuntime_manager.go\n137: \t// gRPC service clients\n138: \truntimeService internalapi.RuntimeService\n139: \timageService   internalapi.ImageManagerService\n140: \n141: \n223: \tctx := context...

Let me read the key files for each component to find the main symbols.

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/lifecycle/interfaces.go\n1: /*\n2: Copyright 2016 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package lifecycle\n18: \n19: import \"k8s.io/api/core/v1\"\n20: \n21: // PodAdmitAttributes is the context for a pod admission decision.\n22: // The member fields of this struct should never be mutated.\n23: type PodAdmitAttributes struct {\n24: \t// the pod to evaluate for admission\n25: \tPod *v1.Pod\n26: \t// all pods bound to the kubelet excluding the pod being evaluated\n27: \tOtherPods []*v1.Pod\n28: }\n29: \n30: // PodAdmitResult provides the result of a pod admission decision.\n31: type PodAdmitResult struct {\n32: \t// if true, the pod should be admitted.\n33: \tAdmit bool\n34: \t// a brief single-word reason why the pod could not be admitted.\n35: \tReason string\n36: \t// a brief message explaining why the pod could not be admitted.\n37: \tMessage string\n38: }\n39: \n40: // PodAdmitHandler is notified during pod admission.\n41: type PodAdmitHandler interface {\n42: \t// Admit evaluates if a pod can be admitted.\n43: \tAdmit(attrs *PodAdmitAttributes) PodAd...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/pleg/pleg.go\n1: /*\n2: Copyright 2015 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package pleg\n18: \n19: import (\n20: \t\"time\"\n21: \n22: \t\"k8s.io/apimachinery/pkg/types\"\n23: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n24: )\n25: \n26: // PodLifeCycleEventType define the event type of pod life cycle events.\n27: type PodLifeCycleEventType string\n28: \n29: type RelistDuration struct {\n30: \t// The period for relisting.\n31: \tRelistPeriod time.Duration\n32: \t// The relisting threshold needs to be greater than the relisting period +\n33: \t// the relisting time, which can vary significantly. Set a conservative\n34: \t// threshold to avoid flipping between healthy and unhealthy.\n35: \tRelistThreshold time.Duration\n36: }\n37: \n38: const (\n39: \t// ContainerStarted - event type when the new state of container is running.\n40: \tContainerStarted PodLifeCycleEventType = \"ContainerStarted\"\n41: \t// ContainerDied - event type when the new state of container is exited.\n42: \tContainerDied PodLifeCycleEventType = \"ContainerDied\"\n43...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/cm/devicemanager/manager.go%3FL1-80\n1: /*\n2: Copyright 2017 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package devicemanager\n18: \n19: import (\n20: \t\"context\"\n21: \tgoerrors \"errors\"\n22: \t\"fmt\"\n23: \t\"os\"\n24: \t\"path/filepath\"\n25: \t\"runtime\"\n26: \t\"sort\"\n27: \t\"sync\"\n28: \t\"time\"\n29: \n30: \tcadvisorapi \"github.com/google/cadvisor/info/v1\"\n31: \t\"k8s.io/klog/v2\"\n32: \n33: \tv1 \"k8s.io/api/core/v1\"\n34: \t\"k8s.io/apimachinery/pkg/api/resource\"\n35: \terrorsutil \"k8s.io/apimachinery/pkg/util/errors\"\n36: \t\"k8s.io/apimachinery/pkg/util/sets\"\n37: \t\"k8s.io/apiserver/pkg/server/healthz\"\n38: \tutilfeature \"k8s.io/apiserver/pkg/util/feature\"\n39: \tpluginapi \"k8s.io/kubelet/pkg/apis/deviceplugin/v1beta1\"\n40: \tpodutil \"k8s.io/kubernetes/pkg/api/v1/pod\"\n41: \t\"k8s.io/kubernetes/pkg/features\"\n42: \t\"k8s.io/kubernetes/pkg/kubelet/checkpointmanager\"\n43: \t\"k8s.io/kubernetes/pkg/kubelet/checkpointmanager/errors\"\n44: \t\"k8s.io/kubernetes/pkg/kubelet/cm/containermap\"\n45: \t\"k8s.io/kubernetes/pkg/kube...

{"text":"No results.\n\nNo results found."}

Now let me look for the CRI client and pod workers implementations, plus the lifecycle handlers file.

{"text":"No results.\n\nNo results found."}

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/lifecycle/handlers.go%3FL1-60\n1: /*\n2: Copyright 2014 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package lifecycle\n18: \n19: import (\n20: \t\"context\"\n21: \t\"errors\"\n22: \t\"fmt\"\n23: \t\"io\"\n24: \t\"net/http\"\n25: \t\"net/url\"\n26: \t\"strconv\"\n27: \t\"strings\"\n28: \t\"time\"\n29: \n30: \tv1 \"k8s.io/api/core/v1\"\n31: \t\"k8s.io/apimachinery/pkg/types\"\n32: \t\"k8s.io/apimachinery/pkg/util/intstr\"\n33: \tutilfeature \"k8s.io/apiserver/pkg/util/feature\"\n34: \t\"k8s.io/client-go/tools/record\"\n35: \t\"k8s.io/klog/v2\"\n36: \t\"k8s.io/kubernetes/pkg/features\"\n37: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n38: \t\"k8s.io/kubernetes/pkg/kubelet/metrics\"\n39: \tkubetypes \"k8s.io/kubernetes/pkg/kubelet/types\"\n40: \t\"k8s.io/kubernetes/pkg/kubelet/util/format\"\n41: \thttpprobe \"k8s.io/kubernetes/pkg/probe/http\"\n42: \t\"k8s.io/kubernetes/pkg/security/apparmor\"\n43: )\n44: \n45: const (\n46: \tmaxRespBodyLength = 10 * 1 << 10 // 10KB\n47: \n48: \tAppArmorNotAdmittedReason = \"AppArmor\"\n49: )\n50: \n51: type handle...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/pleg/generic.go%3FL1-80\n1: /*\n2: Copyright 2015 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package pleg\n18: \n19: import (\n20: \t\"context\"\n21: \t\"fmt\"\n22: \t\"sync\"\n23: \t\"sync/atomic\"\n24: \t\"time\"\n25: \n26: \t\"k8s.io/apimachinery/pkg/types\"\n27: \t\"k8s.io/apimachinery/pkg/util/sets\"\n28: \t\"k8s.io/apimachinery/pkg/util/wait\"\n29: \tutilfeature \"k8s.io/apiserver/pkg/util/feature\"\n30: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n31: \t\"k8s.io/klog/v2\"\n32: \t\"k8s.io/kubernetes/pkg/features\"\n33: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n34: \t\"k8s.io/kubernetes/pkg/kubelet/metrics\"\n35: \t\"k8s.io/utils/clock\"\n36: )\n37: \n38: // GenericPLEG is an extremely simple generic PLEG that relies solely on\n39: // periodic listing to discover container changes. It should be used\n40: // as temporary replacement for container runtimes do not support a proper\n41: // event generator yet.\n42: //\n43: // Note that GenericPLEG assumes that a container would not be created,\n44: // terminated, and garbage collec...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/volumemanager/volume_manager.go%3FL1-100\n1: /*\n2: Copyright 2016 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package volumemanager\n18: \n19: import (\n20: \t\"context\"\n21: \t\"errors\"\n22: \t\"fmt\"\n23: \t\"slices\"\n24: \t\"strconv\"\n25: \t\"strings\"\n26: \t\"sync\"\n27: \t\"time\"\n28: \n29: \tutilfeature \"k8s.io/apiserver/pkg/util/feature\"\n30: \t\"k8s.io/klog/v2\"\n31: \t\"k8s.io/mount-utils\"\n32: \n33: \tv1 \"k8s.io/api/core/v1\"\n34: \tk8stypes \"k8s.io/apimachinery/pkg/types\"\n35: \tutilerrors \"k8s.io/apimachinery/pkg/util/errors\"\n36: \t\"k8s.io/apimachinery/pkg/util/runtime\"\n37: \t\"k8s.io/apimachinery/pkg/util/sets\"\n38: \t\"k8s.io/apimachinery/pkg/util/wait\"\n39: \tclientset \"k8s.io/client-go/kubernetes\"\n40: \t\"k8s.io/client-go/tools/record\"\n41: \tcsitrans \"k8s.io/csi-translation-lib\"\n42: \t\"k8s.io/kubernetes/pkg/kubelet/config\"\n43: \t\"k8s.io/kubernetes/pkg/kubelet/container\"\n44: \t\"k8s.io/kubernetes/pkg/kubelet/volumemanager/cache\"\n45: \t\"k8s.io/kubernetes/pkg/kubelet/volumemanager/metrics\"\n46: \t\"k8s.io/kub...

Let me search for the CRI client implementation and look at the kuberuntime_manager.go for its full structure.

{"text":"No results.\n\nNo results found."}

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/kuberuntime/kuberuntime_manager.go%3FL1-100\n1: /*\n2: Copyright 2016 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package kuberuntime\n18: \n19: import (\n20: \t\"context\"\n21: \t\"errors\"\n22: \t\"fmt\"\n23: \t\"os\"\n24: \t\"path/filepath\"\n25: \t\"sort\"\n26: \t\"time\"\n27: \n28: \tcadvisorapi \"github.com/google/cadvisor/info/v1\"\n29: \t\"go.opentelemetry.io/otel/trace\"\n30: \tgrpcstatus \"google.golang.org/grpc/status\"\n31: \tcrierror \"k8s.io/cri-api/pkg/errors\"\n32: \t\"k8s.io/klog/v2\"\n33: \n34: \tv1 \"k8s.io/api/core/v1\"\n35: \t\"k8s.io/apimachinery/pkg/api/resource\"\n36: \tmetav1 \"k8s.io/apimachinery/pkg/apis/meta/v1\"\n37: \tkubetypes \"k8s.io/apimachinery/pkg/types\"\n38: \tutilruntime \"k8s.io/apimachinery/pkg/util/runtime\"\n39: \tutilversion \"k8s.io/apimachinery/pkg/util/version\"\n40: \tutilfeature \"k8s.io/apiserver/pkg/util/feature\"\n41: \t\"k8s.io/client-go/tools/record\"\n42: \tref \"k8s.io/client-go/tools/reference\"\n43: \t\"k8s.io/client-go/util/flowcontrol\"\n44: \t\"k8s.io/component-base/logs/logreduction\"\n45: \tinterna...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/pod_workers.go%3FL1-100\n1: /*\n2: Copyright 2014 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package kubelet\n18: \n19: import (\n20: \t\"context\"\n21: \t\"fmt\"\n22: \t\"strings\"\n23: \t\"sync\"\n24: \t\"time\"\n25: \n26: \tv1 \"k8s.io/api/core/v1\"\n27: \t\"k8s.io/apimachinery/pkg/types\"\n28: \t\"k8s.io/apimachinery/pkg/util/runtime\"\n29: \t\"k8s.io/apimachinery/pkg/util/wait\"\n30: \t\"k8s.io/client-go/tools/record\"\n31: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n32: \t\"k8s.io/klog/v2\"\n33: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n34: \t\"k8s.io/kubernetes/pkg/kubelet/events\"\n35: \t\"k8s.io/kubernetes/pkg/kubelet/eviction\"\n36: \t\"k8s.io/kubernetes/pkg/kubelet/metrics\"\n37: \tkubetypes \"k8s.io/kubernetes/pkg/kubelet/types\"\n38: \t\"k8s.io/kubernetes/pkg/kubelet/util/queue\"\n39: \t\"k8s.io/utils/clock\"\n40: )\n41: \n42: // OnCompleteFunc is a function that is invoked when an operation completes.\n43: // If err is non-nil, the operation did not complete successfully.\n44: type OnCompleteFunc func(err error)\n45: ...

Let me find the CRI client in the vendor directory and also look for additional files.

{"text":"No files."}

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kubelet.go\n371: \tlogger := klog.Background()\n372: \tif kubeDeps.RemoteRuntimeService, err = remote.NewRemoteRuntimeService(kubeCfg.ContainerRuntimeEndpoint, kubeCfg.RuntimeRequestTimeout.Duration, tp, &logger); err != nil {\n373: \t\treturn err\n374: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – pkg/kubelet/kubelet_test.go\n3215: \tlogger := klog.Background()\n3216: \truntimeService, err := remote.NewRemoteRuntimeService(endpoint, 15*time.Second, tp, &logger)\n3217: \trequire.NoError(t, err)\n3218: \n"}

{"text":"No files."}

{"text":"# github.com/sg-evals/kubernetes--v1.32.0 – cmd/kubeadm/app/util/runtime/runtime_fake_test.go\n39: \t}\n40: \tnewRemoteRuntimeServiceReturns struct {\n41: \t\tres cri.RuntimeService\n42: \n100: \n101: func (fake *fakeImpl) NewRemoteRuntimeServiceReturns(res cri.RuntimeService, err error) {\n102: \tfake.newRemoteRuntimeServiceReturns = struct {\n103: \t\tres cri.RuntimeService\n104: \n95: \n96: func (fake *fakeImpl) NewRemoteRuntimeService(string, time.Duration) (cri.RuntimeService, error) {\n97: \tfakeReturns := fake.newRemoteRuntimeServiceReturns\n98: \treturn fakeReturns.res, fakeReturns.err\n99: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – staging/src/k8s.io/cri-client/pkg/remote_runtime.go\n45: \n46: // remoteRuntimeService is a gRPC implementation of internalapi.RuntimeService.\n47: type remoteRuntimeService struct {\n48: \ttimeout       time.Duration\n49: \n81: \n82: // NewRemoteRuntimeService creates a new internalapi.RuntimeService.\n83: func NewRemoteRuntimeService(endpoint string, connectionTimeout time.Duration, tp trace.TracerProvider, logger *klog.Logger) (internalapi.RuntimeService, error) {\n84: \tinternal.Log(logger, 3, \"Connecting to runtime service\", \"endpoint\", endpoint)\n85: \n126: \n127: \tservice := &remoteRuntimeService{\n128: \t\ttimeout:      connectionTimeout,\n129: \n\n# github.com/sg-evals/kubernetes--v1.32.0 – cmd/kubeadm/app/util/runtime/impl.go\n30: type impl interface {\n31: \tNewRemoteRuntimeService(endpoint string, connectionTimeout time.Duration) (criapi.RuntimeService, error)\n32: \tNewRemoteImageService(endpoint string, connectionTimeout time.Duration) (criapi.ImageManagerService, error)\n33: \n40: \n41: func (*defaultImpl) NewRemoteRuntimeService(endpoint string, connectionTimeout time.Duration) (criapi.RuntimeServic...

Found the CRI client. Let me explore the staging directory and also look at more device manager and lifecycle files.

{"text":"staging/src/k8s.io/cri-client/pkg/fake/\nstaging/src/k8s.io/cri-client/pkg/internal/\nstaging/src/k8s.io/cri-client/pkg/logs/\nstaging/src/k8s.io/cri-client/pkg/util/\nstaging/src/k8s.io/cri-client/pkg/doc.go\nstaging/src/k8s.io/cri-client/pkg/remote_image.go\nstaging/src/k8s.io/cri-client/pkg/remote_image_test.go\nstaging/src/k8s.io/cri-client/pkg/remote_runtime.go\nstaging/src/k8s.io/cri-client/pkg/remote_runtime_test.go\nstaging/src/k8s.io/cri-client/pkg/utils.go\nstaging/src/k8s.io/cri-client/pkg/utils_test.go\n"}

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/staging/src/k8s.io/cri-client/pkg/remote_runtime.go%3FL1-80\n1: /*\n2: Copyright 2016 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package cri\n18: \n19: import (\n20: \t\"context\"\n21: \t\"errors\"\n22: \t\"fmt\"\n23: \t\"io\"\n24: \t\"strings\"\n25: \t\"time\"\n26: \n27: \t\"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc\"\n28: \t\"go.opentelemetry.io/otel/trace\"\n29: \t\"google.golang.org/grpc\"\n30: \t\"google.golang.org/grpc/backoff\"\n31: \t\"google.golang.org/grpc/codes\"\n32: \t\"google.golang.org/grpc/credentials/insecure\"\n33: \t\"google.golang.org/grpc/status\"\n34: \n35: \t\"k8s.io/component-base/logs/logreduction\"\n36: \ttracing \"k8s.io/component-base/tracing\"\n37: \tinternalapi \"k8s.io/cri-api/pkg/apis\"\n38: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n39: \t\"k8s.io/klog/v2\"\n40: \tutilexec \"k8s.io/utils/exec\"\n41: \n42: \t\"k8s.io/cri-client/pkg/internal\"\n43: \t\"k8s.io/cri-client/pkg/util\"\n44: )\n45: \n46: // remoteRuntimeService is a gRPC implementation of internalapi.RuntimeService.\n47: type remoteRunt...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/cm/devicemanager/types.go\n1: /*\n2: Copyright 2017 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package devicemanager\n18: \n19: import (\n20: \t\"time\"\n21: \n22: \tv1 \"k8s.io/api/core/v1\"\n23: \t\"k8s.io/apimachinery/pkg/util/sets\"\n24: \t\"k8s.io/apiserver/pkg/server/healthz\"\n25: \t\"k8s.io/kubernetes/pkg/kubelet/cm/containermap\"\n26: \t\"k8s.io/kubernetes/pkg/kubelet/cm/resourceupdates\"\n27: \t\"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager\"\n28: \t\"k8s.io/kubernetes/pkg/kubelet/config\"\n29: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n30: \t\"k8s.io/kubernetes/pkg/kubelet/lifecycle\"\n31: \t\"k8s.io/kubernetes/pkg/kubelet/pluginmanager/cache\"\n32: \tschedulerframework \"k8s.io/kubernetes/pkg/scheduler/framework\"\n33: )\n34: \n35: // Manager manages all the Device Plugins running on a node.\n36: type Manager interface {\n37: \t// Start starts device plugin registration service.\n38: \tStart(activePods ActivePodsFunc, sourcesReady config.SourcesReady, initialContainers containermap.ContainerMap, initialContainerRunningSet set...

I now have enough information to write a comprehensive answer. Let me read one more file to confirm the remote_image.go CRI client structure.

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/staging/src/k8s.io/cri-client/pkg/remote_image.go%3FL1-60\n1: /*\n2: Copyright 2016 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package cri\n18: \n19: import (\n20: \t\"context\"\n21: \t\"errors\"\n22: \t\"fmt\"\n23: \t\"time\"\n24: \n25: \t\"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc\"\n26: \t\"go.opentelemetry.io/otel/trace\"\n27: \t\"google.golang.org/grpc\"\n28: \t\"google.golang.org/grpc/backoff\"\n29: \t\"google.golang.org/grpc/codes\"\n30: \t\"google.golang.org/grpc/credentials/insecure\"\n31: \t\"google.golang.org/grpc/status\"\n32: \n33: \ttracing \"k8s.io/component-base/tracing\"\n34: \tinternalapi \"k8s.io/cri-api/pkg/apis\"\n35: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n36: \t\"k8s.io/klog/v2\"\n37: \n38: \t\"k8s.io/cri-client/pkg/internal\"\n39: \t\"k8s.io/cri-client/pkg/util\"\n40: )\n41: \n42: // remoteImageService is a gRPC implementation of internalapi.ImageManagerService.\n43: type remoteImageService struct {\n44: \ttimeout     time.Duration\n45: \timageClient runtimeapi.ImageServiceClient\n46: \tlogger      *k...

{"text":"URL: https://demo.sourcegraph.com/github.com/sg-evals/kubernetes--v1.32.0@d17b464c6fcd3273e4b1f695890bf0af7d5b272d/-/blob/pkg/kubelet/pleg/evented.go%3FL1-60\n1: /*\n2: Copyright 2022 The Kubernetes Authors.\n3: \n4: Licensed under the Apache License, Version 2.0 (the \"License\");\n5: you may not use this file except in compliance with the License.\n6: You may obtain a copy of the License at\n7: \n8:     http://www.apache.org/licenses/LICENSE-2.0\n9: \n10: Unless required by applicable law or agreed to in writing, software\n11: distributed under the License is distributed on an \"AS IS\" BASIS,\n12: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n13: See the License for the specific language governing permissions and\n14: limitations under the License.\n15: */\n16: \n17: package pleg\n18: \n19: import (\n20: \t\"context\"\n21: \t\"fmt\"\n22: \t\"sync\"\n23: \t\"time\"\n24: \n25: \t\"k8s.io/apimachinery/pkg/types\"\n26: \t\"k8s.io/apimachinery/pkg/util/wait\"\n27: \tinternalapi \"k8s.io/cri-api/pkg/apis\"\n28: \truntimeapi \"k8s.io/cri-api/pkg/apis/runtime/v1\"\n29: \t\"k8s.io/klog/v2\"\n30: \tkubecontainer \"k8s.io/kubernetes/pkg/kubelet/container\"\n31: \t\"k8s.io/kubernetes/pkg/kubelet/metrics\"\n32: \t\"k8s.io/utils/clock\"\n33: )\n34: \n35: // The frequency with which global timestamp of the cache is to\n36: // is to be updated periodically. If pod workers get stuck at cache.GetNewerThan\n37: // call, after this period it will be unblocked.\n38: const globalCacheUpdatePeriod = 5 * time.Second\n39: \n40: var (\n41: \teventedPLEGUsage   = false\n42: \teventedPLEGUsageMu = sync.RWMutex{}\n43: )\n44: \n45: // isEventedPLEGInUse indicates whether Evented PLEG is in use. Even after enabling\n46: // the Evented PLEG feature gate, there c...

Now I have all the information needed. Let me write the comprehensive `answer.json`.

File created successfully at: /workspace/answer.json (file state is current in your context — no need to Read it back)

The `answer.json` is written. Here's a summary of what I found:

## Major Kubelet Components (sig-node, kubernetes v1.32.0)

### 1. Pod Lifecycle Manager
- **`pkg/kubelet/lifecycle/interfaces.go`** — `PodLifecycleTarget`, `PodAdmitHandler`, `PodSyncLoopHandler`, `PodSyncHandler` interfaces
- **`pkg/kubelet/lifecycle/handlers.go`** — `handlerRunner` executes PostStart/PreStop hooks
- **`pkg/kubelet/pod_workers.go`** — `podWorkers` / `PodWorkers`: per-pod state machine (sync → terminating → terminated)
- **`pkg/kubelet/pleg/pleg.go`** — `PodLifecycleEventGenerator` interface + event types
- **`pkg/kubelet/pleg/generic.go`** — `GenericPLEG`: polling-based PLEG
- **`pkg/kubelet/pleg/evented.go`** — `EventedPLEG`: event-stream-based PLEG

### 2. CRI Client
- **`staging/src/k8s.io/cri-client/pkg/remote_runtime.go`** — `remoteRuntimeService` / `NewRemoteRuntimeService`: gRPC client to container runtime
- **`staging/src/k8s.io/cri-client/pkg/remote_image.go`** — `remoteImageService` / `NewRemoteImageService`: image service client
- **`pkg/kubelet/kuberuntime/kuberuntime_manager.go`** — `kubeGenericRuntimeManager`: Kubernetes-aware wrapper around CRI

### 3. Volume Manager
- **`pkg/kubelet/volumemanager/volume_manager.go`** — `VolumeManager` interface + `volumeManager` implementation

### 4. Device Plugin Manager
- **`pkg/kubelet/cm/devicemanager/types.go`** — `Manager` interface
- **`pkg/kubelet/cm/devicemanager/manager.go`** — `ManagerImpl`: manages device plugin registration, allocation, and checkpointing

I'll map the kubelet components. First, let me look at the workspace structure.

api--v0.32.0
client-go--v0.32.0
etcd-io-etcd
kubernetes--v1.32.0

CHANGELOG
CHANGELOG.md
CONTRIBUTING.md
LICENSE
LICENSES
Makefile
OWNERS
OWNERS_ALIASES
README.md
SECURITY_CONTACTS
SUPPORT.md
api
build
cluster
cmd
code-of-conduct.md
docs
go.mod
go.sum
go.work
go.work.sum
hack
logo
pkg
plugin
staging
test
third_party
vendor
OWNERS
active_deadline.go
active_deadline_test.go
apis
cadvisor
certificate
checkpointmanager
client
cloudresource
clustertrustbundle
cm
config
configmap
container
doc.go
envvars
errors.go
events
eviction
images
kubelet.go
kubelet_getters.go
kubelet_getters_test.go
kubelet_linux.go
kubelet_network.go
kubelet_network_linux.go
kubelet_network_others.go
kubelet_node_status.go
kubelet_node_status_others.go
kubelet_node_status_test.go
kubelet_node_status_windows.go
kubelet_others.go
kubelet_pods.go
kubelet_pods_linux_test.go
kubelet_pods_test.go
kubelet_pods_windows_test.go
kubelet_resources.go
kubelet_resources_test.go
kubelet_server_journal.go
kubelet_server_journal_linux.go
kubelet_server_journal_nonlinux.go
kubelet_server_journal_others.go
kubelet_server_journal_test.go
kubelet_server_journal_windows.go
kubelet_test.go
kubelet_volumes.go
kubelet_volumes_linux_test.go
kubelet_volumes_test.go
kubeletconfig
kuberuntime
lifecycle
logs
metrics
network
nodeshutdown
nodestatus
oom
pleg
pluginmanager
pod

pkg/kubelet/cm/devicemanager:
OWNERS
checkpoint
endpoint.go
endpoint_test.go
manager.go
manager_test.go
plugin
pod_devices.go
pod_devices_test.go
topology_hints.go
topology_hints_test.go
types.go

pkg/kubelet/pleg:
doc.go
evented.go
evented_test.go
generic.go
generic_test.go
pleg.go

pkg/kubelet/volumemanager:
OWNERS
cache
metrics
populator
reconciler
volume_manager.go
volume_manager_fake.go
volume_manager_test.go
---
---
mirror_client.go
mirror_client_test.go
pod_manager.go
pod_manager_test.go
testing

---
doc.go
fake
internal
logs
remote_image.go
remote_image_test.go
remote_runtime.go
remote_runtime_test.go
util
utils.go
utils_test.go
---
runtime
services.go
testing

The CRI client lives in the staging `cri-client` repo dir. Let me confirm the key symbols in each component.

pkg/kubelet/pleg/pleg.go:27:type PodLifeCycleEventType string
pkg/kubelet/pleg/pleg.go:29:type RelistDuration struct {
pkg/kubelet/pleg/pleg.go:55:type PodLifecycleEvent struct {
pkg/kubelet/pleg/pleg.go:67:type PodLifecycleEventGenerator interface {
pkg/kubelet/pleg/pleg.go:79:type podLifecycleEventGeneratorHandler interface {
pkg/kubelet/pleg/pleg.go:87:type WatchCondition = func(*kubecontainer.PodStatus) bool
pkg/kubelet/pleg/evented.go:63:type EventedPLEG struct {
pkg/kubelet/pleg/evented.go:91:func NewEventedPLEG(logger klog.Logger, runtime kubecontainer.Runtime, runtimeService internalapi.RuntimeService, eventChannel chan *PodLifecycleEvent,
pkg/kubelet/pleg/generic.go:53:type GenericPLEG struct {
pkg/kubelet/pleg/generic.go:89:type versionedWatchCondition struct {
pkg/kubelet/pleg/generic.go:98:type plegContainerState string
pkg/kubelet/pleg/generic.go:123:type podRecord struct {
pkg/kubelet/pleg/generic.go:128:type podRecords map[types.UID]*podRecord
pkg/kubelet/pleg/generic.go:131:func NewGenericPLEG(logger klog.Logger, runtime kubecontainer.Runtime, eventChannel chan *PodLifecycleEvent,
===
93:type VolumeManager interface {
161:type PodStateProvider interface {
168:type PodManager interface {
181:func NewVolumeManager(
243:type volumeManager struct {
===
59:type ActivePodsFunc func() []*v1.Pod
62:type ManagerImpl struct {
118:type endpointInfo struct {
123:type sourcesReadyStub struct{}
126:type PodReusableDevices map[string]map[string]sets.Set[string]
132:func NewManagerImpl(topology []cadvisorapi.Node, topologyAffinityStore topologymanager.Store) (*ManagerImpl, error) {
===
staging/src/k8s.io/cri-client/pkg/remote_image.go:43:type remoteImageService struct {
staging/src/k8s.io/cri-client/pkg/remote_image.go:50:func NewRemoteImageService(endpoint string, conn...

pkg/kubelet/volumemanager/cache:
actual_state_of_world.go
actual_state_of_world_test.go
desired_state_of_wold_selinux_metrics.go
desired_state_of_world.go
desired_state_of_world_test.go

pkg/kubelet/volumemanager/populator:
desired_state_of_world_populator.go
desired_state_of_world_populator_test.go

pkg/kubelet/volumemanager/reconciler:
reconciler.go
reconciler_common.go
reconciler_test.go
reconstruct.go
reconstruct_common.go
reconstruct_test.go
===
pkg/kubelet/cm/devicemanager/plugin:
v1beta1

pkg/kubelet/cm/devicemanager/plugin/v1beta1:
api.go
client.go
handler.go
server.go
stub.go
===
142:type PodWorkers interface {
600:func newPodWorkers(
===
runtime
services.go
testing

I have everything I need. Writing the answer file now.

File created successfully at: /workspace/answer.json (file state is current in your context — no need to Read it back)

Done — `/workspace/answer.json` is written. All four components are in the `kubernetes/kubernetes` checkout (`kubernetes--v1.32.0`, v1.32.0):

- **Pod lifecycle manager (PLEG)** — `pkg/kubelet/pleg/`: `pleg.go` defines the `PodLifecycleEventGenerator` interface, `generic.go` implements the relist-based `GenericPLEG`, and `evented.go` the CRI-event-driven `EventedPLEG`. I also included the supporting pod manager (`pkg/kubelet/pod/pod_manager.go`) and pod workers (`pkg/kubelet/pod_workers.go`), which drive per-pod lifecycle state machines.
- **CRI client** — moved to the staging repo `k8s.io/cri-client`: `staging/src/k8s.io/cri-client/pkg/remote_runtime.go` (`NewRemoteRuntimeService`) and `remote_image.go` implement the `RuntimeService`/`ImageManagerService` interfaces from `staging/src/k8s.io/cri-api/pkg/apis/services.go`. The kubelet-side consumer is `pkg/kubelet/kuberuntime/kuberuntime_manager.go` (`NewKubeGenericRuntimeManager`).
- **Volume manager** — `pkg/kubelet/volumemanager/volume_manager.go` (`VolumeManager`, `NewVolumeManager`), with the desired-state populator, reconciler, and actual/desired state-of-world caches in its `populator/`, `reconciler/`, and `cache/` subpackages.
- **Device plugin manager** — `pkg/kubelet/cm/devicemanager/manager.go` (`ManagerImpl`, `NewManagerImpl`), plus `endpoint.go`, `pod_devices.go`, `topology_hints.go`, and the device-plugin gRPC registration server/client under `plugin/v1beta1/`.

The answer also includes a wiring chain: `NewMainKubelet` in `pkg/kubelet/kubelet.go` constructs the CRI remote services, the kuberuntime manager, the PLEG, and the volume manager, and the device manager comes in via the container manager.