john-deng/hicli-vendor: github.com/openshift/origin/pkg/oc/admin/diagnostics/diagnostics/cluster/route_validation.go; 14 LoC

Found a possible issue in [john-deng/hicli-vendor](https://www.github.com/john-deng/hicli-vendor) at [github.com/openshift/origin/pkg/oc/admin/diagnostics/diagnostics/cluster/route_validation.go](https://github.com/john-deng/hicli-vendor/blob/bba4ecd772d120ba795d0d4d3f70db0b0bd0c508/github.com/openshift/origin/pkg/oc/admin/diagnostics/diagnostics/cluster/route_validation.go#L85-L98)

Below is the message reported by the analyzer for this snippet of code. Beware that the analyzer only reports the first
issue it finds, so please do not limit your consideration to the contents of the below message.

> function call which takes a reference to route at line 90 may start a goroutine

[Click here to see the code in its original context.](https://github.com/john-deng/hicli-vendor/blob/bba4ecd772d120ba795d0d4d3f70db0b0bd0c508/github.com/openshift/origin/pkg/oc/admin/diagnostics/diagnostics/cluster/route_validation.go#L85-L98)

Click here to show the 14 line(s) of Go which triggered the analyzer.

```go
for _, route := range routes.Items {
original := route.DeepCopy()
errs := validation.ExtendedValidateRoute(&route)

if len(errs) == 0 {
if !kapihelper.Semantic.DeepEqual(original, &route) {
err := fmt.Errorf("Route was normalized when extended validation was run (route/%s -n %s).\nPlease verify that this route certificate contains no invalid data.\n", route.Name, route.Namespace)
r.Warn("DRouCert2004", nil, err.Error())
}
continue
}
err = fmt.Errorf("Route failed extended validation (route/%s -n %s):\n%s", route.Name, route.Namespace, flattenErrors(errs))
r.Error("DRouCert2005", nil, err.Error())
}

```

Click here to show extra information the analyzer produced.

```
The following dot graph describes paths through the callgraph that could lead to a function calling a goroutine:
digraph G {
"(Run, 3)" -> {"(NewServer, 1)";"(startProfiler, 0)";"(StartNode, 0)";"(Filter, 2)";}
"(VerifyPodsRunning, 5)" -> {"(podRunningMaybeResponding, 6)";}
"(readPreface, 0)" -> {}
"(updateEgressNetworkPolicy, 1)" -> {"(OnEndpointsAdd, 1)";}
"(runKubeletInProcess, 1)" -> {"(NewKubeletCommand, 0)";}
"(RunBuildControllerTest, 3)" -> {"(Watch, 1)";"(Stop, 0)";}
"(Filter, 2)" -> {}
"(locateArrayElement, 2)" -> {"(Skip, 0)";}
"(Errorf, 2)" -> {"(printf, 3)";}
"(authenticateToMaster, 2)" -> {}
"(reconcile, 0)" -> {"(attachDesiredVolumes, 0)";"(AttachVolume, 2)";}
"(removeAndReAdd, 1)" -> {}
"(Key, 6)" -> {"(deriveKey, 9)";}
"(ensurePodsAreRemovedWhenNamespaceIsDeleted, 1)" -> {}
"(WatchList, 4)" -> {"(watch, 5)";"(Watch, 4)";"(newEtcdWatcher, 9)";}
"(Tar, 2)" -> {"(TarWithOptions, 2)";}
"(Version, 1)" -> {"(Errorf, 2)";}
"(initMetaData, 0)" -> {}
"(Writer, 0)" -> {"(WriterLevel, 1)";}
"(getStartDialLocked, 1)" -> {}
"(Build, 0)" -> {"(pullImage, 3)";"(dockerBuild, 3)";"(pushImage, 3)";}
"(Create, 2)" -> {"(Wait, 1)";}
"(patchResource, 18)" -> {"(finishRequest, 2)";}
"(URL, 0)" -> {"(Set, 2)";}
"(setup, 0)" -> {"(Start, 0)";}
"(setupDumpStackTrap, 1)" -> {}
"(StartSync, 3)" -> {}
"(RunPortForward, 0)" -> {"(ForwardPorts, 3)";}
"(runOVSHealthCheck, 3)" -> {}
"(NewSSHTunnelList, 4)" -> {"(delayedHealthCheck, 2)";}
"(holdHijackedConnection, 4)" -> {}
"(Files, 1)" -> {"(checkFiles, 1)";}
"(NewListWatchServiceLookup, 2)" -> {}
"(newResourceConsumer, 15)" -> {}
"(CreateKubeNamespace, 2)" -> {"(PollImmediate, 3)";}
"(startServingTLS, 5)" -> {}
"(Do, 1)" -> {"(createWatchReadCloser, 2)";"(Set, 2)";}
"(Union, 1)" -> {"(Insert, 1)";}
"(Size, 0)" -> {"(DiffSize, 2)";}
"(runOnce, 2)" -> {"(runPod, 2)";}
"(configureKubeConfigForClientCertRotation, 2)" -> {"(RefreshCertificateAfterExpiry, 4)";}
"(Catalog, 1)" -> {"(Do, 1)";}
"(TimedWaitForAnImageStreamTag, 5)" -> {}
"(runCommand, 1)" -> {"(RunCmd, 1)";}
"(Example, 0)" -> {"(Key, 6)";}
"(AbsPath, 1)" -> {"(Join, 1)";}
"(Watch, 2)" -> {"(WatchPredicate, 3)";}
"(NewBroadcaster, 2)" -> {}
"(NewREST, 1)" -> {"(CompleteWithOptions, 1)";}
"(listenOnPort, 1)" -> {"(listenOnPortAndAddress, 3)";}
"(StartExec, 3)" -> {"(holdHijackedConnection, 5)";}
"(RunImageChangeTriggerTest, 3)" -> {"(Watch, 1)";"(Stop, 0)";}
"(connect, 3)" -> {}
"(monitorSize, 2)" -> {"(monitorResizeEvents, 3)";}
"(StartOnce, 0)" -> {}
"(children, 4)" -> {"(Scan, 2)";}
"(TarWithOptions, 2)" -> {}
"(pullImage, 3)" -> {}
"(start, 3)" -> {"(StateChanged, 2)";}
"(dumpMetrics, 0)" -> {"(ServeHTTP, 2)";}
"(resetWithDocker, 2)" -> {"(Check, 0)";}
"(newPortRangeAllocator, 2)" -> {}
"(createAllResources, 3)" -> {}
"(NewServer, 1)" -> {}
"(dockerBuild, 3)" -> {"(buildImage, 4)";}
"(RESTClient, 0)" -> {"(Set, 2)";}
"(roundTrip, 1)" -> {"(awaitOpenSlotForRequest, 1)";"(scheduleBodyWrite, 0)";}
"(runOnce, 0)" -> {}
"(Stream, 0)" -> {"(tryThrottle, 0)";"(Do, 1)";}
"(NewCRDFinalizer, 3)" -> {"(NewNamedRateLimitingQueue, 2)";}
"(GetValidatedClusterInfoObject, 1)" -> {"(RetrieveValidatedClusterInfo, 3)";}
"(AddPod, 1)" -> {}
"(CompleteWithOptions, 1)" -> {"(startObservingCount, 1)";"(GetRESTOptions, 1)";}
"(serve, 0)" -> {"(readPreface, 0)";"(startPush, 1)";}
"(kill, 0)" -> {}
"(preparePod, 4)" -> {"(Copy, 2)";"(RunCommand, 2)";}
"(WaitStop, 1)" -> {"(wait, 2)";}
"(Kill, 1)" -> {"(WaitStop, 1)";}
"(ApplyAll, 1)" -> {}
"(sendConsumeCPURequests, 4)" -> {}
"(Bind, 2)" -> {}
"(checkFiles, 1)" -> {"(collectObjects, 0)";}
"(timeoutFlush, 1)" -> {}
"(StartGarbageCollection, 0)" -> {}
"(initDiscovery, 1)" -> {"(initDiscovery, 3)";}
"(ListPodStats, 0)" -> {"(Infof, 2)";}
"(Stop, 0)" -> {"(kill, 0)";"(Do, 1)";}
"(QueryForEntries, 2)" -> {"(Bind, 2)";}
"(pullSchema2, 3)" -> {"(Download, 4)";}
"(serve, 2)" -> {}
"(Untar, 3)" -> {"(untarHandler, 4)";}
"(syncLoopIteration, 5)" -> {"(HandlePodCleanups, 0)";}
"(Channel, 1)" -> {}
"(handleConnection, 2)" -> {}
"(AddHeader, 1)" -> {"(append, 2)";}
"(get, 1)" -> {"(SetTransportDefaults, 1)";"(Close, 0)";"(child, 2)";}
"(shutdownDaemon, 1)" -> {}
"(printf, 3)" -> {"(output, 5)";}
"(ContainerExecAttach, 4)" -> {"(holdHijackedConnection, 4)";"(ContainerExecAttach, 3)";}
"(AttachStreams, 9)" -> {}
"(Logs, 3)" -> {"(logs, 2)";}
"(Recognizes, 1)" -> {"(init, 0)";}
"(RetrieveBindingsByInstance, 1)" -> {"(List, 1)";}
"(Watch, 5)" -> {}
"(testRollingUpdateDeployment, 1)" -> {"(VerifyPodsRunning, 5)";}
"(execute, 7)" -> {"(Stream, 1)";}
"(Start, 1)" -> {"(Serve, 1)";"(start, 0)";"(doChecking, 0)";"(updateEgressNetworkPolicy, 1)";"(start, 1)";"(events, 1)";"(StartWithLogFile, 2)";}
"(startPollingLogs, 0)" -> {}
"(Shutdown, 0)" -> {"(ApplyAll, 1)";"(shutdownContainer, 1)";}
"(Reload, 1)" -> {"(reloadClusterDiscovery, 1)";}
"(checkStreamFrame, 1)" -> {}
"(SyncServices, 1)" -> {}
"(wait, 2)" -> {}
"(newConnection, 2)" -> {}
"(OpenAPISchema, 0)" -> {"(Do, 1)";}
"(withConfigGetFreshApiserverAndClient, 2)" -> {}
"(killPod, 4)" -> {"(KillPod, 3)";}
"(SetupEgressNetworkPolicy, 0)" -> {}
"(DoRaw, 0)" -> {"(tryThrottle, 0)";}
"(dial, 1)" -> {"(dialClientConn, 2)";}
"(WithCancel, 1)" -> {"(propagateCancel, 2)";}
"(copyToPod, 6)" -> {}
"(reloadConfig, 0)" -> {"(Reload, 1)";}
"(Attach, 8)" -> {"(Stream, 1)";}
"(CopyOnBuild, 4)" -> {"(CopyFileWithTar, 2)";}
"(ProxyTCP, 2)" -> {}
"(RetrieveInstancesByPlan, 1)" -> {"(List, 1)";}
"(curlUnix, 2)" -> {"(Dial, 2)";"(SetTransportDefaults, 1)";}
"(killContainer, 5)" -> {"(executePreStopHook, 4)";}
"(NewEncoder, 1)" -> {"(init, 0)";}
"(handleConsumeMem, 2)" -> {"(sendConsumeMemRequests, 4)";}
"(changeWorker, 1)" -> {}
"(IsRBACEnabled, 1)" -> {"(Do, 1)";}
"(run, 1)" -> {"(NewBroadcaster, 0)";"(setup, 1)";"(Set, 2)";"(Complete, 3)";"(ContainerAttachRaw, 5)";"(ContainerWait, 2)";"(ContainerKill, 2)";"(SetUp, 1)";"(newTestController, 1)";}
"(After, 1)" -> {"(Add, 1)";}
"(processHeaders, 1)" -> {"(handleResponse, 2)";}
"(StartAPI, 1)" -> {"(RunDNSServer, 0)";}
"(cancellableHandler, 1)" -> {}
"(Do, 3)" -> {}
"(ExecSync, 2)" -> {"(exec, 8)";}
"(forward, 0)" -> {"(listenOnPort, 1)";}
"(testDeploymentCleanUpPolicy, 1)" -> {"(VerifyPodsRunning, 5)";}
"(testProportionalScalingDeployment, 1)" -> {"(VerifyPodsRunning, 5)";}
"(sortAndDeduplicateRBACRulesFields, 1)" -> {"(List, 0)";}
"(save, 1)" -> {"(Tar, 2)";}
"(Errorln, 1)" -> {"(println, 2)";}
"(ServeConn, 2)" -> {"(serve, 0)";}
"(runLifecycleHooks, 3)" -> {}
"(CheckPodsCondition, 6)" -> {}
"(Matches, 1)" -> {"(List, 0)";}
"(createAggregatorServer, 3)" -> {"(NewWithDelegate, 1)";}
"(NewKubectlCommand, 4)" -> {"(NewCmdPortForward, 3)";"(NewCmdCp, 3)";"(NewCmdTop, 3)";"(NewCmdCompletion, 2)";"(NewCmdDrain, 3)";}
"(CopyWithTar, 2)" -> {"(CopyFileWithTar, 2)";"(TarUntar, 2)";}
"(Pull, 2)" -> {"(pullV2Repository, 2)";"(pullRepository, 2)";}
"(waitPreStopHooks, 2)" -> {"(runLifecycleHooks, 3)";}
"(Delete, 0)" -> {"(NewClient, 3)";}
"(RetrieveBindings, 1)" -> {"(List, 1)";}
"(Diff, 2)" -> {"(ExportChanges, 4)";"(exportLayer, 2)";"(ChangesDirs, 2)";"(TarWithOptions, 2)";}
"(CreateVolume, 2)" -> {"(Connect, 2)";"(init, 0)";}
"(ContainerLogs, 4)" -> {"(ReadLogs, 1)";}
"(OptimizedMatches, 3)" -> {"(regexpMatch, 2)";}
"(pushV2Repository, 1)" -> {"(pushV2Tag, 3)";}
"(AddProcess, 5)" -> {}
"(KillPod, 3)" -> {"(waitPreStopHooks, 2)";"(killPodWithSyncResult, 3)";}
"(ContainerStats, 3)" -> {"(subscribeToContainerStats, 1)";}
"(pathExistsInRegistry, 2)" -> {"(Join, 1)";}
"(run, 4)" -> {"(run, 1)";}
"(marshalDoc, 2)" -> {"(init, 0)";}
"(WaitForSchedulerAfterAction, 4)" -> {"(ObserveEventAfterAction, 3)";}
"(NewSchedulerServer, 2)" -> {"(NewBroadcaster, 0)";}
"(TarUntar, 2)" -> {"(TarWithOptions, 2)";}
"(ApplyLayer, 2)" -> {"(applyLayerHandler, 4)";}
"(monitor, 0)" -> {}
"(Wait, 1)" -> {"(serveAPI, 0)";}
"(processWindowUpdate, 1)" -> {"(scheduleFrameWrite, 0)";}
"(append, 2)" -> {"(Unlock, 0)";"(, 0)";}
"(Unlock, 0)" -> {"(Close, 0)";}
"(connectToFirewallD, 0)" -> {}
"(NewUnboundedExecutor, 0)" -> {"(WithCancel, 1)";}
"(newInternal, 4)" -> {"(connectToFirewallD, 0)";}
"(request, 1)" -> {"(Copy, 2)";"(tryThrottle, 0)";}
"(digForCNAMEs, 2)" -> {"(Insert, 1)";}
"(HandleResizing, 2)" -> {}
"(Init, 4)" -> {"(NewDeviceSet, 5)";}
"(DeepEqual, 2)" -> {"(Type, 0)";"(deepValueEqual, 4)";}
"(RetrieveInstances, 1)" -> {"(List, 1)";}
"(grabFromKubeletInternal, 2)" -> {"(getMetricsFromNode, 2)";}
"(Get, 5)" -> {"(WaitUntilFreshAndGet, 3)";}
"(evictPods, 3)" -> {}
"(NewKubeletCommand, 0)" -> {"(BootstrapKubeletConfigController, 2)";}
"(propagateCancel, 2)" -> {}
"(initInformers, 1)" -> {}
"(Execute, 3)" -> {"(reloadConfig, 0)";}
"(subscribeToContainerStats, 1)" -> {"(collect, 1)";}
"(Work, 0)" -> {}
"(RunRC, 1)" -> {"(start, 0)";}
"(newPlugin, 0)" -> {"(Init, 1)";}
"(Resume, 0)" -> {}
"(WriterLevel, 1)" -> {}
"(tryEchoTCP, 1)" -> {"(DialTCP, 3)";}
"(serveUpgrade, 2)" -> {}
"(ContainerAttachRaw, 5)" -> {"(containerAttach, 7)";}
"(CombinedOutput, 0)" -> {"(exec, 5)";"(run, 0)";}
"(checkDockerStorageDriver, 0)" -> {"(runCommand, 2)";}
"(waitForInstanceToBeDeleted, 3)" -> {"(Poll, 3)";}
"(initRouter, 3)" -> {"(NewRouter, 2)";}
"(Cancellable, 1)" -> {"(cancellableHandler, 1)";}
"(downloadImage, 4)" -> {"(pullImage, 5)";}
"(followLogs, 4)" -> {}
"(NewCmdDrain, 3)" -> {"(RunDrain, 0)";}
"(NewImageManager, 6)" -> {"(newSerialImagePuller, 1)";}
"(newStatsCollector, 1)" -> {}
"(updateConfig, 2)" -> {"(UploadFileToContainer, 2)";}
"(startKubelet, 5)" -> {}
"(serveAPI, 0)" -> {}
"(Run, 2)" -> {"(run, 0)";"(initForOS, 1)";"(List, 0)";"(StartRecordingToSink, 1)";"(reconcileNodeRoutes, 0)";"(Prune, 0)";"(createWorker, 7)";"(InitLogs, 0)";"(run, 2)";"(Execute, 3)";"(CreateServerChain, 2)";"(DialTCP, 3)";"(worker, 0)";"(Run, 3)";"(Do, 1)";"(RunInContainer, 4)";"(Sync, 0)";}
"(NewConnection, 1)" -> {"(NewClientConnection, 1)";}
"(Pods, 1)" -> {"(List, 1)";"(NewSimpleClientset, 1)";}
"(CreateFromProvider, 1)" -> {"(CreateFromKeys, 3)";}
"(SchedulerConfig, 0)" -> {"(CreateFromProvider, 1)";"(CreateFromConfig, 1)";}
"(DialForUpgrade, 1)" -> {"(dial, 2)";}
"(restart, 0)" -> {"(kill, 0)";}
"(testStackdriverAcceleratorMonitoring, 1)" -> {"(SetupNVIDIAGPUNode, 2)";}
"(DaemonJoinsCluster, 1)" -> {"(setClusterProvider, 1)";}
"(CreateAndInitKubelet, 30)" -> {"(NewMainKubelet, 30)";"(StartGarbageCollection, 0)";}
"(clearState, 0)" -> {"(DaemonLeavesCluster, 0)";}
"(untarHandler, 4)" -> {"(DecompressStream, 1)";}
"(handleNodeUpdate, 1)" -> {"(processPodOnNode, 5)";}
"(startControllers, 7)" -> {}
"(CreatePods, 8)" -> {"(Server, 3)";}
"(exportContainerRw, 1)" -> {"(TarStream, 0)";}
"(OnServiceAdd, 1)" -> {"(mergeService, 1)";"(OnServiceUpdate, 2)";}
"(newUnsafeArrayType, 2)" -> {"(Size, 0)";}
"(List, 2)" -> {"(children, 4)";}
"(Checkout, 2)" -> {"(run, 3)";}
"(serverHandshake, 1)" -> {"(newServerTransport, 4)";}
"(startPod, 0)" -> {"(startServing, 2)";"(startServingTLS, 5)";}
"(ChangesDirs, 2)" -> {"(collectFileInfoForChanges, 2)";}
"(ExecInContainer, 9)" -> {"(StartExec, 3)";}
"(collectObjects, 0)" -> {"(importPackage, 3)";}
"(makeScannerString, 1)" -> {"(init, 0)";}
"(StartNode, 0)" -> {"(RunNode, 0)";}
"(NewCmdPortForward, 3)" -> {"(RunPortForward, 0)";}
"(TestNotReachableUDP, 3)" -> {"(Dial, 2)";}
"(UploadFileToContainer, 2)" -> {"(UploadFileToContainer, 4)";}
"(Output, 0)" -> {"(runWithOutput, 0)";"(exec, 5)";}
"(curl, 1)" -> {"(SetTransportDefaults, 1)";}
"(serveResource, 6)" -> {"(DeleteCollection, 4)";}
"(BulkVerifyVolumes, 1)" -> {"(DisksAreAttached, 1)";}
"(run, 2)" -> {"(watchForLockfileContention, 2)";"(Start, 0)";"(StartSync, 3)";"(UpdateTransport, 4)";"(New, 5)";"(RunKubelet, 4)";"(NewKubeletClientCertificateManager, 6)";}
"(handle, 1)" -> {"(WaitForRunningBuild, 3)";"(Stream, 1)";}
"(SetTransportDefaults, 1)" -> {"(ConfigureTransport, 1)";}
"(IsPodSecurityPolicyEnabled, 1)" -> {"(Do, 1)";}
"(newQuerier, 0)" -> {}
"(WaitForBindingToNotExist, 3)" -> {"(PollImmediate, 3)";}
"(NewPluginInitializer, 6)" -> {}
"(ConnectWithRedirects, 5)" -> {"(Dial, 1)";}
"(NewClient, 3)" -> {}
"(CreateTemplates, 5)" -> {"(Server, 3)";}
"(nodesSyncLoop, 0)" -> {}
"(runCopy, 5)" -> {"(copyFromPod, 5)";"(copyToPod, 6)";}
"(NewNamespaceController, 6)" -> {"(NewNamedRateLimitingQueue, 2)";}
"(authorizedCert, 3)" -> {"(verify, 3)";}
"(GetContainerStats, 1)" -> {"(ContainerStats, 3)";}
"(New, 3)" -> {"(newInternal, 4)";}
"(Provision, 6)" -> {"(Create, 1)";}
"(OnServiceSynced, 0)" -> {"(syncProxyRules, 0)";}
"(Create, 3)" -> {"(CopyWithTar, 2)";"(initInformers, 1)";}
"(OnServiceUpdate, 2)" -> {"(mergeService, 1)";}
"(New, 1)" -> {"(startNewNode, 1)";"(Start, 1)";"(Run, 2)";"(Parse, 1)";"(loadState, 0)";"(Errorf, 2)";"(WriteString, 1)";"(New, 0)";"(Update, 1)";"(Close, 0)";"(PollUntil, 3)";"(NewREST, 2)";"(NewClient, 3)";"(restore, 0)";"(Connect, 1)";"(New, 3)";"(NewNamingConditionController, 2)";"(NewCRDFinalizer, 3)";"(New, 2)";"(Run, 1)";"(worker, 0)";"(Remove, 1)";"(NewDiscoveryController, 4)";}
"(RunUntil, 1)" -> {}
"(NonBlockingRun, 4)" -> {}
"(Dial, 2)" -> {"(dial, 4)";"(dialStreamLocal, 1)";}
"(Replace, 4)" -> {"(Do, 0)";}
"(NewCancelReadCloser, 2)" -> {}
"(NewRecorder, 1)" -> {"(Filter, 2)";}
"(Describe, 2)" -> {"(List, 0)";"(ReplicationControllers, 1)";"(Insert, 1)";"(List, 1)";}
"(Complete, 3)" -> {"(EnsureHostDirectories, 1)";}
"(NewAuthenticator, 3)" -> {"(newAuthenticator, 7)";}
"(NewKubeadmCommand, 3)" -> {"(NewCmdUpgrade, 1)";}
"(kexLoop, 0)" -> {}
"(createWatchReadCloser, 2)" -> {"(NewWatchBuffer, 1)";}
"(Token, 0)" -> {"(Accept, 0)";}
"(NewKubeletClientCertificateManager, 6)" -> {"(NewManager, 1)";}
"(For, 1)" -> {"(GetValidatedClusterInfoObject, 1)";}
"(Reset, 1)" -> {"(Close, 0)";"(Add, 1)";}
"(StartBuildAndWait, 2)" -> {"(Build, 0)";}
"(copy, 1)" -> {"(streamingArchive, 1)";}
"(NewStreamWatcher, 1)" -> {}
"(tryUpgrade, 2)" -> {"(ConnectWithRedirects, 5)";"(DialForUpgrade, 1)";}
"(GenerateAllFiles, 0)" -> {"(Init, 1)";}
"(Unbind, 2)" -> {}
"(RetrieveClassByName, 1)" -> {"(List, 1)";}
"(pushRepository, 1)" -> {"(pushImageToEndpoint, 5)";}
"(ProxyProtocolHTTPBackendAvailable, 1)" -> {"(Copy, 2)";"(Dial, 2)";}
"(listSystemIPs, 0)" -> {}
"(ForwardPorts, 3)" -> {"(ForwardPorts, 0)";}
"(cmdStream, 2)" -> {}
"(reloadClusterDiscovery, 1)" -> {"(Reload, 3)";}
"(UploadFileToContainer, 4)" -> {"(newContainerUploader, 3)";}
"(NewConnection, 2)" -> {"(monitor, 0)";}
"(holdHijackedConnection, 5)" -> {}
"(BeforeEach, 0)" -> {"(StartGatheringData, 0)";"(Grab, 0)";}
"(processIncomingEvents, 1)" -> {"(processEvents, 1)";}
"(ExtractMembers, 1)" -> {"(QueryForEntries, 2)";}
"(portForward, 4)" -> {}
"(newUnsafeSliceType, 2)" -> {"(Size, 0)";}
"(followJournal, 5)" -> {}
"(Run, 0)" -> {"(Start, 1)";"(Put, 3)";"(Create, 1)";"(RunRC, 1)";"(Run, 2)";"(Serve, 1)";"(Stop, 0)";"(NewSchedulerServer, 2)";"(Update, 1)";"(Run, 1)";"(Work, 0)";"(printGraphBuildErrors, 1)";"(RunJob, 1)";"(Commit, 0)";"(NewListWatchServiceLookup, 2)";"(List, 0)";"(RunReplicaSet, 1)";"(ProxyProtocolHTTPBackendAvailable, 1)";"(Commit, 2)";"(Attach, 8)";"(NewProxyServer, 1)";"(StartRecordingToSink, 1)";"(Pods, 1)";"(runWithOutput, 0)";"(Create, 3)";"(List, 1)";"(exec, 5)";"(RunEtcd, 1)";"(Build, 0)";"(dumpMetrics, 0)";"(writeToDisk, 4)";"(NewEncoder, 1)";"(RunDeployment, 1)";"(NewPrometheusCollector, 1)";"(StartReaper, 0)";"(Do, 0)";"(Flush, 0)";"(MonitorSize, 1)";"(Poll, 3)";"(NewKubeadmCommand, 3)";"(run, 1)";"(acquire, 0)";"(ReplicationControllers, 1)";"(Generate, 1)";"(Delete, 2)";"(Open, 2)";"(New, 2)";"(Insert, 1)";"(sync, 0)";"(InitLogs, 0)";"(renew, 0)";"(RunKubelet, 4)";"(Run, 3)";"(Create, 2)";"(NewKubectlCommand, 4)";"(Execute, 8)";"(Listen, 0)";"(streamPathToBuild, 8)";"(SyncLoop, 0)";"(Provision, 0)";"(Get, 3)";"(Copy, 2)";"(NewPodStore, 4)";}
"(run, 0)" -> {"(portForward, 1)";"(processHeaders, 1)";"(runOnce, 0)";"(Execute, 3)";"(processSettings, 1)";"(start, 0)";"(processWindowUpdate, 1)";"(GetContainerStats, 1)";"(Publish, 1)";"(cancelOnInterrupt, 2)";"(start, 3)";"(init, 0)";}
"(StartMonitors, 0)" -> {}
"(init, 0)" -> {"(NewServer, 1)";}
"(withAggregator, 3)" -> {"(createAggregatorServer, 4)";}
"(ForResource, 1)" -> {"(Example, 0)";}
"(dnsQueryWithTimeout, 3)" -> {}
"(createTestController, 5)" -> {}
"(waitUntilFreshAndBlock, 2)" -> {}
"(output, 5)" -> {"(timeoutFlush, 1)";}
"(runUpgradeSuite, 7)" -> {"(Register, 1)";}
"(restore, 0)" -> {"(Register, 1)";"(ShouldRestart, 0)";}
"(Get, 0)" -> {"(Get, 3)";"(Do, 0)";"(request, 1)";"(Delete, 1)";"(Get, 5)";"(CombinedOutput, 0)";"(Get, 2)";"(Initialize, 1)";"(Do, 1)";}
"(StartWithLogFile, 2)" -> {}
"(ExportChanges, 4)" -> {}
"(SetUpAt, 2)" -> {"(AttachVolume, 2)";}
"(StopAndSummarize, 2)" -> {}
"(GetAllDrivers, 0)" -> {"(GetAllByCap, 1)";}
"(Upload, 3)" -> {"(makeUploadFunc, 1)";"(Transfer, 3)";}
"(killPodWithSyncResult, 3)" -> {"(killContainersWithSyncResult, 3)";}
"(GetKubeletPods, 2)" -> {"(getKubeletPods, 3)";}
"(BuildInsecureClient, 1)" -> {"(SetTransportDefaults, 1)";}
"(Update, 1)" -> {"(Do, 0)";"(List, 0)";}
"(Connect, 2)" -> {"(connect, 3)";"(NewManager, 1)";}
"(StartLogging, 1)" -> {"(StartEventWatcher, 1)";}
"(waitExit, 2)" -> {"(StateChanged, 2)";}
"(dialStreamLocal, 1)" -> {}
"(AssertDeletedStorageFiles, 2)" -> {"(Insert, 1)";}
"(gatherTestSuiteMetrics, 0)" -> {"(Grab, 0)";}
"(ContainerExecStart, 5)" -> {"(AttachStreams, 9)";"(AddProcess, 5)";}
"(newPodContainerDeletor, 2)" -> {}
"(resolveSearch, 3)" -> {"(dnsQueryWithTimeout, 3)";}
"(scaleDown, 5)" -> {"(run, 4)";}
"(StartCmdAndStreamOutput, 1)" -> {"(Start, 0)";}
"(Replace, 1)" -> {"(Remove, 2)";}
"(Evaluate, 1)" -> {}
"(RunDrain, 0)" -> {"(deleteOrEvictPodsSimple, 1)";}
"(Type, 0)" -> {"(append, 2)";"(AddHeader, 1)";"(Get, 1)";"(Type2, 1)";}
"(Mkdir, 2)" -> {"(Create, 3)";}
"(ReplicationControllers, 1)" -> {"(NewSimpleClientset, 1)";}
"(Migrate, 6)" -> {"(CalculateLayerChecksums, 3)";}
"(runDensityBatchTest, 5)" -> {"(deletePodsSync, 2)";"(newInformerWatchPod, 4)";"(createBatchPodWithRateControl, 3)";}
"(ObjectKinds, 1)" -> {"(init, 0)";}
"(Encode, 1)" -> {"(marshalDoc, 2)";}
"(GetContainerLogTail, 4)" -> {"(GetContainerLogs, 5)";}
"(StartJenkinsMemoryTracking, 2)" -> {}
"(NewDynamicResourceConsumer, 11)" -> {"(newResourceConsumer, 15)";}
"(NewCmdTopPod, 3)" -> {"(Bind, 1)";}
"(SetupNVIDIAGPUNode, 2)" -> {}
"(Sync, 0)" -> {"(ListGroups, 0)";"(ExtractMembers, 1)";}
"(CreateFromKeys, 3)" -> {"(MakeDefaultErrorFunc, 2)";}
"(resetWithCrictl, 4)" -> {"(resetWithDocker, 2)";}
"(Len, 0)" -> {"(String, 0)";}
"(newControllerContext, 7)" -> {"(ToGenericInformer, 0)";}
"(Transfer, 3)" -> {}
"(Upload, 2)" -> {"(uploadUsingSession, 4)";}
"(List, 1)" -> {"(Insert, 1)";"(List, 5)";"(Do, 0)";"(List, 2)";"(List, 0)";}
"(newSession, 2)" -> {}
"(RegisterChange, 0)" -> {"(changeWorker, 1)";}
"(ReadLogs, 1)" -> {"(readLogs, 2)";}
"(NewClientConn, 3)" -> {"(newMux, 1)";"(clientHandshake, 2)";}
"(Resume, 1)" -> {"(Resume, 0)";}
"(Set, 1)" -> {"(Parse, 1)";"(Replace, 1)";"(Insert, 1)";"(Warningf, 2)";"(Infof, 2)";}
"(WaitForBrokerToNotExist, 2)" -> {"(PollImmediate, 3)";}
"(WaitForClusterServiceClassToExist, 2)" -> {"(PollImmediate, 3)";}
"(Validate, 0)" -> {"(List, 0)";"(Insert, 1)";"(Errorln, 1)";"(Errorf, 2)";"(Size, 0)";"(Validate, 1)";}
"(startEventsMonitor, 0)" -> {"(handleEventStream, 1)";}
"(tryThrottle, 0)" -> {"(Accept, 0)";}
"(ReturnIterator, 1)" -> {"(Put, 1)";}
"(getClientConn, 3)" -> {"(getStartDialLocked, 1)";}
"(syncPod, 1)" -> {"(SyncPod, 5)";"(killPod, 4)";}
"(Start, 2)" -> {"(Bind, 1)";"(updateConfig, 2)";}
"(NewManager, 1)" -> {"(reload, 0)";}
"(EnsureHostDirectories, 1)" -> {"(Bind, 1)";}
"(NewSourceURL, 5)" -> {}
"(gatherMetrics, 1)" -> {"(Grab, 0)";}
"(DeleteCollection, 4)" -> {"(DeleteCollection, 3)";}
"(ForwardPorts, 0)" -> {"(forward, 0)";}
"(Run, 1)" -> {"(run, 1)";"(StartMonitors, 0)";"(NewBroadcaster, 0)";"(StartLogging, 1)";"(StartRecordingToSink, 1)";"(patchResource, 18)";"(StartControllers, 5)";"(RunUntil, 1)";"(startControllers, 7)";"(Register, 2)";"(Start, 0)";"(syncLoop, 2)";"(handleNodeUpdate, 1)";"(ListAndWatch, 1)";"(waitForAPIAndKubelet, 1)";"(installSSHKeySyncLoop, 2)";"(List, 0)";"(handlePodUpdate, 1)";"(processEvents, 1)";"(Serve, 3)";"(Insert, 1)";"(WaitForSuccessfulDial, 6)";"(reset, 3)";"(monitorNodeStatus, 0)";"(Run, 2)";"(withAggregator, 3)";"(Shutdown, 0)";"(processIncomingEvents, 1)";"(PanicOnGRPCStuckThreads, 2)";"(Start, 1)";"(startMonitors, 0)";"(New, 5)";"(PollImmediate, 3)";"(Do, 0)";"(NewSSHTunnelList, 4)";"(AggregateGoroutines, 1)";"(OnEndpointsSynced, 0)";"(SchedulerConfig, 0)";"(Stop, 0)";"(nodesSyncLoop, 0)";"(NonBlockingRun, 1)";"(OnServiceSynced, 0)";"(For, 1)";"(reconciliationLoopFunc, 0)";}
"(handlePodUpdate, 1)" -> {"(processPodOnNode, 5)";}
"(GenerateBulkVolumeVerifyFunc, 4)" -> {"(BulkVerifyVolumes, 1)";}
"(makeDownloadFunc, 3)" -> {}
"(createWorker, 7)" -> {}
"(Format, 1)" -> {"(Do, 1)";}
"(NewCacherFromConfig, 1)" -> {"(newTimeBudget, 1)";}
"(NewNamedDelayingQueue, 1)" -> {"(newDelayingQueue, 2)";}
"(deleteOrEvictPods, 1)" -> {"(evictPods, 3)";}
"(waitTillNPodsRunningOnNodes, 6)" -> {}
"(Initialize, 1)" -> {"(NewBroadcaster, 0)";"(StartLogging, 1)";"(StartRecordingToSink, 1)";}
"(Flush, 0)" -> {"(Copy, 2)";"(Do, 1)";}
"(GetRESTOptions, 1)" -> {"(StorageWithCacher, 1)";}
"(RunCompletion, 4)" -> {"(run, 3)";}
"(startLocalProxy, 0)" -> {"(NewServer, 1)";}
"(DumpPodLogsStartingWith, 2)" -> {"(List, 1)";}
"(NewString, 1)" -> {"(Insert, 1)";}
"(attachToLog, 1)" -> {"(Writer, 0)";}
"(Setup, 0)" -> {}
"(generateEvent, 5)" -> {}
"(handleEventStream, 1)" -> {}
"(Scan, 2)" -> {}
"(importPackage, 3)" -> {"(ImportFrom, 3)";}
"(Put, 3)" -> {"(init, 0)";}
"(watch, 3)" -> {"(Filter, 2)";}
"(WaitForEndpoint, 3)" -> {"(PollImmediate, 3)";}
"(startServing, 2)" -> {}
"(updateCachedPodVolumeStats, 0)" -> {"(StartOnce, 0)";}
"(Get, 3)" -> {"(Get, 5)";"(WaitForRunningBuild, 3)";"(Do, 3)";"(exec, 5)";}
"(runContainerdDaemon, 0)" -> {}
"(addEndpoint, 1)" -> {}
"(CheckPodsRunningReadyOrSucceeded, 4)" -> {"(CheckPodsCondition, 6)";}
"(ObserveEventAfterAction, 3)" -> {}
"(RetrievePlanByName, 1)" -> {"(List, 1)";}
"(Services, 1)" -> {"(List, 1)";}
"(podRunningMaybeResponding, 6)" -> {"(podsRunning, 2)";}
"(updateTransport, 5)" -> {}
"(cleanupOrphanedPodCgroups, 2)" -> {}
"(Start, 3)" -> {}
"(OnEndpointsSynced, 0)" -> {"(syncProxyRules, 0)";}
"(pullRepository, 2)" -> {"(downloadImage, 4)";}
"(Validate, 1)" -> {"(Evaluate, 1)";}
"(RetrievePlansByClass, 1)" -> {"(List, 1)";}
"(watch, 5)" -> {"(Watch, 5)";}
"(AddWork, 3)" -> {"(CreateWorker, 4)";}
"(awaitOpenSlotForRequest, 1)" -> {}
"(attachDesiredVolumes, 0)" -> {"(AttachVolume, 2)";}
"(Register, 2)" -> {"(addEndpoint, 1)";"(Do, 1)";}
"(writeToDisk, 4)" -> {"(Copy, 2)";}
"(monitor, 4)" -> {}
"(StartNode, 2)" -> {"(RunProxy, 0)";"(RunDNS, 0)";"(runKubeletInProcess, 1)";}
"(startMonitoring, 0)" -> {}
"(headersForConfig, 1)" -> {"(RoundTrip, 1)";}
"(dial, 4)" -> {}
"(startFrameWrite, 1)" -> {}
"(startMonitors, 0)" -> {}
"(poller, 2)" -> {}
"(handleResponse, 2)" -> {"(on100, 0)";}
"(updateHealthMonitor, 1)" -> {"(monitor, 4)";}
"(exec, 5)" -> {"(ContainerExecAttach, 4)";}
"(NewSchemeBuilder, 1)" -> {"(Register, 1)";}
"(runContextCommand, 4)" -> {"(CopyOnBuild, 4)";}
"(runPod, 2)" -> {"(syncPod, 1)";}
"(StartApiserverCPUProfileGatherer, 1)" -> {}
"(Init, 1)" -> {"(listSystemIPs, 0)";}
"(List, 0)" -> {"(list, 0)";}
"(monitorResizeEvents, 3)" -> {}
"(sendConsumeMemRequests, 4)" -> {}
"(CreateFromConfig, 1)" -> {"(CreateFromKeys, 3)";}
"(WaitForAnImageStreamTag, 4)" -> {"(TimedWaitForAnImageStreamTag, 5)";}
"(WaitForBindingCondition, 4)" -> {"(PollImmediate, 3)";}
"(UpdateTransport, 4)" -> {"(updateTransport, 5)";}
"(on100, 0)" -> {}
"(processSettings, 1)" -> {"(scheduleFrameWrite, 0)";}
"(UpdateStatus, 1)" -> {"(Do, 0)";}
"(Infof, 2)" -> {"(printf, 3)";}
"(Purge, 1)" -> {"(Commit, 0)";}
"(New, 17)" -> {"(NewImageManager, 6)";}
"(runDensityTest, 2)" -> {}
"(listenOnPortAndAddress, 3)" -> {"(waitForConnection, 2)";}
"(getVolume, 1)" -> {"(Purge, 1)";"(Get, 2)";"(GetAllDrivers, 0)";}
"(AggregateGoroutines, 1)" -> {}
"(NewDiscoveryController, 4)" -> {"(NewNamedRateLimitingQueue, 2)";}
"(WaitForAttachedDevice, 1)" -> {}
"(SyncPod, 5)" -> {"(killPodWithSyncResult, 3)";"(killContainer, 5)";"(KillPod, 3)";"(RunPod, 2)";}
"(notifySystem, 0)" -> {}
"(parse, 0)" -> {"(init, 0)";"(Token, 0)";}
"(Error, 0)" -> {"(List, 0)";"(Insert, 1)";}
"(Write, 1)" -> {"(checkCapacityAndRotate, 0)";"(printWithFileLine, 5)";"(Set, 2)";}
"(StartTestServerOrDie, 3)" -> {"(StartTestServer, 3)";}
"(typeCheck, 2)" -> {"(Check, 4)";}
"(Join, 1)" -> {}
"(installSSHKeySyncLoop, 2)" -> {}
"(Decode, 3)" -> {"(ObjectKinds, 1)";}
"(reset, 3)" -> {"(resetWithDocker, 2)";"(resetWithCrictl, 4)";}
"(runResourceUsageTest, 3)" -> {"(deletePodsSync, 2)";}
"(Set, 2)" -> {"(Scan, 1)";"(Commit, 0)";"(save, 1)";}
"(CreateBatch, 1)" -> {}
"(getInternal, 1)" -> {"(Add, 1)";}
"(delayedHealthCheck, 2)" -> {"(removeAndReAdd, 1)";}
"(WatchPredicate, 3)" -> {"(newDecoratedWatcher, 2)";}
"(scheduleBodyWrite, 0)" -> {}
"(ExecSync, 3)" -> {"(ExecSync, 2)";}
"(Open, 2)" -> {"(ServeHTTP, 2)";}
"(copyStdout, 1)" -> {}
"(Prune, 0)" -> {"(ListGroups, 0)";}
"(ImportFrom, 3)" -> {"(parseFiles, 2)";}
"(containerAttach, 7)" -> {"(ReadLogs, 1)";"(WaitStop, 1)";"(Attach, 4)";}
"(unref, 0)" -> {}
"(deleteImages, 1)" -> {"(RunCmd, 1)";}
"(Check, 4)" -> {"(Files, 1)";}
"(Prefix, 1)" -> {"(Join, 1)";}
"(Read, 1)" -> {"(Copy, 2)";"(Do, 1)";"(Set, 2)";}
"(newInformerWatchPod, 4)" -> {}
"(WaitForInstanceCondition, 4)" -> {"(PollImmediate, 3)";}
"(RunControllerServer, 2)" -> {"(serveControllers, 2)";}
"(NewDeviceSet, 5)" -> {"(initDevmapper, 1)";}
"(NewCustomProxier, 10)" -> {"(newPortAllocator, 1)";}
"(RunServer, 4)" -> {}
"(NewMainKubelet, 30)" -> {"(newPodContainerDeletor, 2)";"(makePodSourceConfig, 4)";"(NewKubeGenericRuntimeManager, 18)";"(New, 17)";}
"(newPortAllocator, 1)" -> {"(newPortRangeAllocator, 2)";}
"(SyncLoop, 0)" -> {}
"(doTestMustConnectSendNothing, 2)" -> {"(Dial, 2)";}
"(start, 0)" -> {"(Diff, 2)";}
"(WaitUntilFreshAndList, 2)" -> {"(waitUntilFreshAndBlock, 2)";}
"(DisksAreAttached, 1)" -> {}
"(createBatchPodWithRateControl, 3)" -> {}
"(watchForLockfileContention, 2)" -> {}
"(RunReplicaSet, 1)" -> {"(start, 0)";}
"(WaitForBrokerCondition, 3)" -> {"(PollImmediate, 3)";}
"(RunScaleTest, 0)" -> {}
"(deletePodsSync, 2)" -> {}
"(worker, 0)" -> {"(handle, 1)";"(processNextWorkItem, 0)";}
"(testNvidiaGPUsOnCOS, 1)" -> {"(SetupNVIDIAGPUNode, 2)";"(StopAndSummarize, 2)";}
"(RetrievePlans, 0)" -> {"(List, 1)";}
"(getKubeletPods, 3)" -> {"(NodeProxyRequest, 3)";}
"(processNextWorkItem, 0)" -> {"(sync, 1)";}
"(runForEndpointsAndReturnFirst, 2)" -> {}
"(enable, 3)" -> {"(attachToLog, 1)";}
"(start, 1)" -> {"(Trap, 1)";"(startMetricsServer, 1)";"(setupConfigReloadTrap, 0)";"(Wait, 1)";"(notifySystem, 0)";"(shutdownDaemon, 1)";"(StateChanged, 2)";"(Accept, 2)";"(NewDaemon, 3)";"(Init, 4)";"(RestartSwarmContainers, 0)";"(Start, 0)";"(initRouter, 3)";"(waitExit, 2)";}
"(PanicOnGRPCStuckThreads, 2)" -> {}
"(events, 1)" -> {}
"(Publish, 1)" -> {}
"(Execute, 8)" -> {"(Stream, 1)";}
"(sendConsumeCustomMetric, 5)" -> {}
"(Remove, 1)" -> {"(remove, 1)";"(Next, 0)";"(Delete, 1)";"(Purge, 1)";"(Delete, 2)";"(Remove, 2)";}
"(Sync, 2)" -> {"(Update, 1)";}
"(handleGoAwayFrame, 1)" -> {}
"(createAggregatorServer, 4)" -> {"(NewWithDelegate, 1)";}
"(Put, 1)" -> {"(Commit, 0)";}
"(testMulticast, 2)" -> {}
"(dumpObjectReadiness, 2)" -> {"(Do, 0)";}
"(checkDockerNetworkServer, 0)" -> {"(runCommand, 2)";}
"(SubResource, 1)" -> {"(Join, 1)";}
"(locateObjectField, 2)" -> {"(Skip, 0)";}
"(dialClientConn, 2)" -> {"(newClientConn, 2)";}
"(newSourceApiserverFromLW, 2)" -> {}
"(Parse, 1)" -> {"(makeScannerString, 1)";"(Push, 1)";"(Set, 2)";"(handle, 1)";"(Add, 1)";"(Flush, 0)";"(parse, 0)";"(Build, 0)";}
"(runCommand, 2)" -> {}
"(CreateVolume, 1)" -> {}
"(Unbind, 4)" -> {"(Do, 1)";}
"(Provision, 4)" -> {"(NewEncoder, 1)";"(Do, 1)";}
"(ContainerKill, 2)" -> {"(Kill, 1)";}
"(NewProxier, 9)" -> {"(NewCustomProxier, 10)";}
"(NewKubeGenericRuntimeManager, 18)" -> {"(NewImageManager, 6)";}
"(Parallelize, 3)" -> {}
"(copyStderr, 1)" -> {}
"(Attach, 4)" -> {"(AttachStreams, 9)";}
"(sync, 0)" -> {"(syncStates, 0)";}
"(uploadUsingSession, 4)" -> {"(compress, 1)";}
"(runServiceLatencies, 3)" -> {"(newQuerier, 0)";"(startEndpointWatcher, 2)";}
"(deepValueEqual, 4)" -> {"(Index, 1)";"(Len, 0)";"(IsValid, 0)";}
"(NodeProxyRequest, 3)" -> {}
"(RunEtcd, 1)" -> {}
"(InitLogs, 0)" -> {}
"(StartRecordingToSink, 1)" -> {"(StartEventWatcher, 1)";}
"(exec, 8)" -> {"(ExecInContainer, 9)";}
"(NewServer, 2)" -> {"(serve, 2)";}
"(buildImage, 4)" -> {}
"(Deprovision, 3)" -> {"(Do, 1)";}
"(RunNode, 0)" -> {"(StartNode, 2)";}
"(makeUploadFunc, 1)" -> {"(Upload, 2)";}
"(NewFromJSON, 1)" -> {"(New, 1)";}
"(InitService, 1)" -> {}
"(RunCmd, 1)" -> {"(WaitOnCmd, 2)";}
"(CreateWorker, 4)" -> {}
"(Search, 2)" -> {"(Insert, 1)";"(Infof, 2)";"(Warningf, 2)";"(Do, 0)";"(Connect, 2)";"(List, 1)";"(Create, 1)";}
"(watchErrorStream, 2)" -> {}
"(reconciliationLoopFunc, 0)" -> {"(reconcile, 0)";}
"(newProxyServer, 5)" -> {"(NewProxier, 9)";}
"(handleBumpMetric, 2)" -> {"(sendConsumeCustomMetric, 5)";}
"(Delete, 1)" -> {"(Remove, 2)";}
"(Commit, 2)" -> {"(exportContainerRw, 1)";"(containerUnpause, 1)";}
"(getPodContainerStatuses, 3)" -> {"(GetContainerLogTail, 4)";}
"(pullV2Repository, 2)" -> {"(pullV2Tag, 2)";}
"(IsValid, 0)" -> {"(Validate, 0)";}
"(maybeReportTransition, 0)" -> {}
"(reconcile, 2)" -> {}
"(RunSecurityAllocationController, 0)" -> {}
"(Push, 1)" -> {"(pushRepository, 1)";"(pushV2Repository, 1)";}
"(xzDecompress, 1)" -> {"(cmdStream, 2)";}
"(StartCompactor, 3)" -> {}
"(Bind, 1)" -> {"(Bind, 2)";}
"(RetrieveValidatedClusterInfo, 3)" -> {"(runForEndpointsAndReturnFirst, 2)";}
"(SetUp, 1)" -> {"(SetUpAt, 2)";}
"(Trap, 1)" -> {}
"(RunKubelet, 4)" -> {"(startKubelet, 5)";"(CreateAndInitKubelet, 30)";"(RunOnce, 1)";}
"(WaitForSuccessfulDial, 6)" -> {"(Dial, 2)";}
"(Background, 0)" -> {"(Start, 0)";}
"(DumpNodeDebugInfo, 3)" -> {"(GetKubeletPods, 2)";}
"(Remove, 2)" -> {}
"(handleConsumeCPU, 2)" -> {"(sendConsumeCPURequests, 4)";}
"(NewSession, 0)" -> {"(newSession, 2)";}
"(GetNode, 0)" -> {"(GetNodeInfo, 1)";}
"(Bind, 6)" -> {"(Create, 1)";}
"(WriteString, 1)" -> {"(printf, 3)";}
"(Query, 2)" -> {"(Do, 0)";}
"(runDensitySeqTest, 4)" -> {"(deletePodsSync, 2)";}
"(Serve, 3)" -> {"(ConfigureServer, 2)";"(RunServer, 4)";}
"(newClientTransport, 6)" -> {"(kexLoop, 0)";}
"(sshExec, 2)" -> {"(NewSession, 0)";}
"(DiscoverNode, 1)" -> {}
"(NewNamedRateLimitingQueue, 2)" -> {"(NewNamedDelayingQueue, 1)";}
"(DiffSize, 2)" -> {"(Changes, 2)";}
"(GetResource, 3)" -> {"(Get, 3)";}
"(DeleteVolume, 2)" -> {"(Wait, 1)";"(Connect, 2)";}
"(AddObjectsToTemplate, 3)" -> {"(ObjectKinds, 1)";}
"(pushImageToEndpoint, 5)" -> {}
"(GetPodStatus, 3)" -> {"(Warningf, 2)";"(getPodContainerStatuses, 3)";}
"(OpenWebSocketForURL, 3)" -> {"(headersForConfig, 1)";}
"(authenticateToRegistry, 2)" -> {"(dnsQueryWithTimeout, 3)";}
"(Provision, 0)" -> {"(CreateVolume, 1)";}
"(collectFileInfoForChanges, 2)" -> {}
"(Start, 0)" -> {"(Setup, 0)";"(dial, 1)";"(Do, 1)";"(RunControllerServer, 2)";"(Start, 3)";"(NewBroadcaster, 0)";"(RunOnce, 0)";"(newControllerContext, 7)";"(Start, 2)";"(UpdatePod, 1)";"(startControllers, 3)";"(startMaster, 0)";"(NewServer, 1)";"(SetupEgressNetworkPolicy, 0)";"(Serve, 1)";"(BuildMasterConfig, 2)";"(Initialize, 1)";"(New, 5)";"(startPod, 0)";"(Create, 0)";"(StartLogging, 1)";"(StartRecordingToSink, 1)";"(StartAPI, 1)";"(SetupSDN, 0)";"(copy, 1)";"(updateCachedPodVolumeStats, 0)";"(NewNamespaceController, 6)";}
"(Call, 3)" -> {"(NewEncoder, 1)";}
"(serveControllers, 2)" -> {}
"(BootstrapKubeletConfigController, 2)" -> {"(Bootstrap, 0)";}
"(ObserveNodeUpdateAfterAction, 4)" -> {}
"(renew, 0)" -> {"(maybeReportTransition, 0)";"(do, 1)";}
"(handleResizes, 0)" -> {}
"(StartEventWatcher, 1)" -> {}
"(NewSimpleClientset, 1)" -> {"(Watch, 2)";}
"(streamingArchive, 1)" -> {}
"(SimpleGET, 3)" -> {"(Do, 1)";}
"(processPodOnNode, 5)" -> {"(AddWork, 3)";}
"(deleteAllResources, 3)" -> {}
"(Receive, 2)" -> {"(Copy, 2)";}
"(Exists, 1)" -> {"(ExtractMembers, 1)";}
"(NewCmdApply, 1)" -> {"(RunApply, 1)";}
"(NewClientConnection, 1)" -> {"(NewConnection, 2)";"(newConnection, 2)";}
"(getBackendConn, 5)" -> {}
"(Add, 1)" -> {"(List, 0)";"(Errorf, 2)";"(add, 4)";"(unref, 0)";"(watch, 3)";"(addPod, 1)";"(ObjectKinds, 1)";"(Insert, 1)";"(Size, 0)";}
"(extinguish, 4)" -> {"(DeleteNamespaces, 3)";}
"(GetCodecForObject, 1)" -> {"(ObjectKinds, 1)";"(Recognizes, 1)";}
"(printWithFileLine, 5)" -> {"(output, 5)";}
"(testRolloverDeployment, 1)" -> {"(VerifyPodsRunning, 5)";}
"(RunCommand, 2)" -> {"(RunCmd, 1)";}
"(addServicePortPortal, 5)" -> {"(ProxyLoop, 3)";}
"(Load, 1)" -> {"(Validate, 2)";"(Close, 0)";"(Get, 0)";"(Decode, 3)";"(Infof, 2)";"(Version, 1)";}
"(RestartSwarmContainers, 0)" -> {"(ShouldRestart, 0)";}
"(checkDockerSeccomp, 0)" -> {"(runCommand, 1)";}
"(InstanceToServiceClassAndPlan, 1)" -> {}
"(RunBuildConfigChangeControllerTest, 2)" -> {"(Watch, 1)";"(Stop, 0)";}
"(SetupSDN, 0)" -> {"(runOVSHealthCheck, 3)";}
"(ShouldRestart, 0)" -> {"(ShouldRestart, 3)";}
"(GetAllByCap, 1)" -> {"(GetAll, 1)";}
"(copyFromPod, 5)" -> {}
"(deleteInstances, 1)" -> {"(DeleteCollection, 3)";}
"(doTestMustConnectSendDisconnect, 2)" -> {"(DialTCP, 3)";}
"(newDecoratedWatcher, 2)" -> {}
"(RunBuildDeleteTest, 3)" -> {"(Watch, 1)";"(Stop, 0)";}
"(runDiagnosticPod, 1)" -> {}
"(Download, 4)" -> {"(makeDownloadFuncFromDownload, 3)";"(makeDownloadFunc, 3)";}
"(Bind, 5)" -> {"(NewEncoder, 1)";"(Do, 1)";}
"(testReboot, 3)" -> {}
"(New, 0)" -> {"(NewREST, 2)";"(New, 2)";"(New, 3)";}
"(initDiscovery, 3)" -> {}
"(NewCmdCompletion, 2)" -> {"(RunCompletion, 4)";}
"(ListHealthChecks, 0)" -> {"(List, 2)";}
"(newETCD3Storage, 1)" -> {"(StartCompactor, 3)";"(New, 5)";}
"(clientHandshake, 2)" -> {"(newClientTransport, 6)";}
"(Reload, 3)" -> {}
"(CloseNotify, 0)" -> {}
"(ExecOrDie, 0)" -> {"(Exec, 0)";}
"(RunInContainer, 4)" -> {"(RunInContainer, 3)";}
"(getBackendConn, 7)" -> {}
"(RunJob, 1)" -> {"(start, 0)";}
"(GetNodeInfo, 1)" -> {"(RediscoverNode, 1)";}
"(RunBuildRunningPodDeleteTest, 3)" -> {"(Watch, 1)";"(Stop, 0)";}
"(RetrieveBrokers, 0)" -> {"(List, 1)";}
"(setClusterProvider, 1)" -> {}
"(getFreshApiserverAndClient, 3)" -> {"(withConfigGetFreshApiserverAndClient, 2)";}
"(shutdownContainer, 1)" -> {"(WaitStop, 1)";}
"(writeRemoteFile, 5)" -> {"(NewSession, 0)";"(Copy, 2)";}
"(CreateServerChain, 2)" -> {"(NonBlockingRun, 4)";"(createAggregatorServer, 3)";}
"(processBlocks, 5)" -> {}
"(Watch, 4)" -> {"(newCacheWatcher, 6)";"(newEtcdWatcher, 9)";"(watch, 5)";}
"(Matches, 2)" -> {"(OptimizedMatches, 3)";}
"(Warningf, 2)" -> {"(printf, 3)";}
"(logs, 2)" -> {}
"(NewCmdUpgrade, 1)" -> {"(NewCmdApply, 1)";}
"(RunApply, 1)" -> {"(PrepullImagesInParallel, 2)";}
"(syncStates, 0)" -> {"(VerifyVolumesAreAttached, 2)";}
"(Generate, 1)" -> {"(GenerateAllFiles, 0)";}
"(checkDockerConfig, 0)" -> {"(runCommand, 1)";}
"(add, 4)" -> {"(runContextCommand, 4)";}
"(RunPod, 2)" -> {"(runLifecycleHooks, 3)";}
"(proxyTCP, 2)" -> {}
"(Poll, 3)" -> {"(poller, 2)";}
"(List, 5)" -> {"(WaitUntilFreshAndList, 2)";}
"(getMasterSSHClient, 0)" -> {"(Dial, 3)";}
"(GetByKey, 1)" -> {"(Remove, 1)";}
"(TarStream, 0)" -> {"(Diff, 2)";}
"(digForPTRRecords, 2)" -> {"(Insert, 1)";}
"(ServeHTTP, 2)" -> {"(tryUpgrade, 2)";"(handleConsumeCPU, 2)";"(handleConsumeMem, 2)";"(handleBumpMetric, 2)";"(serveResource, 6)";"(serveUpgrade, 2)";}
"(Update, 2)" -> {"(Remove, 2)";}
"(finishRequest, 2)" -> {}
"(VerifyPods, 5)" -> {"(podRunningMaybeResponding, 6)";}
"(newCacheWatcher, 6)" -> {}
"(println, 2)" -> {"(output, 5)";}
"(killContainersWithSyncResult, 3)" -> {}
"(Insert, 1)" -> {"(gc, 0)";}
"(child, 2)" -> {"(Scan, 1)";}
"(DeleteCollection, 3)" -> {}
"(RoundTrip, 1)" -> {"(RoundTripOpt, 2)";"(roundTrip, 1)";"(Dial, 1)";}
"(NewServerConn, 2)" -> {"(serverHandshake, 1)";}
"(newAuthenticator, 7)" -> {}
"(NewDaemon, 3)" -> {"(newStatsCollector, 1)";"(setupDumpStackTrap, 1)";"(NewManager, 1)";"(NewReferenceStore, 1)";"(Migrate, 6)";"(initDiscovery, 1)";}
"(portForward, 1)" -> {"(PortForward, 4)";}
"(readLogs, 2)" -> {"(followJournal, 5)";"(followLogs, 4)";}
"(Bootstrap, 0)" -> {}
"(Scan, 1)" -> {"(Scan, 2)";}
"(switchService, 1)" -> {"(OnServiceAdd, 1)";}
"(runTestWithController, 3)" -> {}
"(do, 1)" -> {"(authorizedCert, 3)";}
"(testZonalFailover, 2)" -> {}
"(getCredentialsFromStore, 1)" -> {"(Get, 2)";}
"(gcTerminated, 1)" -> {}
"(GetClientConn, 2)" -> {"(getClientConn, 3)";}
"(dial, 3)" -> {"(tlsDial, 3)";}
"(pullImage, 5)" -> {"(Download, 4)";}
"(newStaticTable, 0)" -> {"(init, 0)";}
"(reload, 0)" -> {}
"(deleteOrEvictPodsSimple, 1)" -> {"(deleteOrEvictPods, 1)";}
"(newProxyServer, 4)" -> {"(NewProxier, 9)";}
"(PollUntil, 3)" -> {"(poller, 2)";}
"(WaitForInstanceToNotExist, 3)" -> {"(PollImmediate, 3)";}
"(exportHTTP, 2)" -> {}
"(RunOnce, 0)" -> {"(Accept, 0)";}
"(parseFiles, 2)" -> {}
"(RunDNSServer, 0)" -> {}
"(verify, 3)" -> {"(fulfill, 3)";}
"(Suffix, 1)" -> {"(Join, 1)";}
"(StateChanged, 2)" -> {"(updateHealthMonitor, 1)";"(ShouldRestart, 3)";"(enable, 3)";}
"(Delete, 2)" -> {"(Wait, 1)";"(Do, 0)";"(Update, 1)";"(Accept, 2)";}
"(Serve, 1)" -> {"(frameHandler, 2)";"(checkStreamFrame, 1)";"(handleGoAwayFrame, 1)";"(NewPriorityFrameQueue, 1)";}
"(Event, 4)" -> {"(generateEvent, 5)";}
"(Signal, 1)" -> {"(Do, 1)";}
"(StringKeySet, 1)" -> {"(Insert, 1)";}
"(OnEndpointsAdd, 1)" -> {"(switchService, 1)";}
"(RediscoverNode, 1)" -> {"(DiscoverNode, 1)";}
"(WaitOnCmd, 2)" -> {}
"(Register, 1)" -> {"(newPlugin, 0)";}
"(Grab, 0)" -> {"(grabFromKubeletInternal, 2)";}
"(wrapType, 1)" -> {"(newUnsafeArrayType, 2)";"(newUnsafeSliceType, 2)";}
"(Exec, 0)" -> {"(Start, 0)";}
"(scaleUp, 5)" -> {"(run, 4)";}
"(GetAll, 1)" -> {}
"(createClients, 1)" -> {"(SetTransportDefaults, 1)";}
"(NewPrometheusCollector, 1)" -> {"(Register, 1)";}
"(mergeService, 1)" -> {"(addServiceOnPort, 4)";"(addServicePortPortal, 5)";}
"(tlsDial, 3)" -> {"(tlsDialWithDialer, 4)";}
"(Close, 0)" -> {"(Read, 1)";"(Delete, 1)";"(Do, 1)";"(deleteImages, 1)";"(Errorf, 2)";"(shutdown, 1)";"(Remove, 1)";"(remove, 1)";"(Sync, 0)";"(sync, 0)";"(Flush, 0)";"(Put, 1)";"(Write, 1)";}
"(Validate, 2)" -> {"(Validate, 1)";"(Do, 0)";"(Errorf, 2)";"(Infof, 2)";}
"(ListAndWatch, 1)" -> {}
"(getMetricsFromNode, 2)" -> {}
"(ShouldRestart, 3)" -> {}
"(NewWithDelegate, 1)" -> {}
"(ConfigureServer, 2)" -> {"(ServeConn, 2)";}
"(String, 0)" -> {"(List, 0)";"(WriteString, 1)";"(Size, 0)";}
"(startProfiler, 0)" -> {}
"(RefreshCertificateAfterExpiry, 4)" -> {}
"(StartTestServer, 3)" -> {}
"(makeDownloadFuncFromDownload, 3)" -> {}
"(Listen, 0)" -> {"(Serve, 1)";}
"(applyLayerHandler, 4)" -> {"(DecompressStream, 1)";}
"(newServerTransport, 4)" -> {}
"(DialTCP, 3)" -> {"(dial, 4)";}
"(Dial, 1)" -> {"(dial, 2)";}
"(waitSinkInit, 0)" -> {"(pullAndAck, 2)";}
"(Process, 1)" -> {"(Do, 0)";}
"(newEtcdWatcher, 9)" -> {}
"(PortForward, 3)" -> {"(portForward, 4)";}
"(Dial, 3)" -> {"(NewClientConn, 3)";}
"(NewProxyServer, 1)" -> {"(newProxyServer, 5)";"(newProxyServer, 4)";}
"(waitForConnection, 2)" -> {"(handleConnection, 2)";}
"(Create, 1)" -> {"(Do, 0)";"(Update, 1)";"(newETCD3Storage, 1)";}
"(RunProxy, 0)" -> {}
"(newTestController, 1)" -> {"(getFreshApiserverAndClient, 3)";}
"(addPod, 1)" -> {"(AddPod, 1)";}
"(NewNetworkingTestConfig, 1)" -> {"(setup, 1)";}
"(dial, 2)" -> {"(NewServerConn, 2)";}
"(setupConfigReloadTrap, 0)" -> {"(reloadConfig, 0)";}
"(podsRunning, 2)" -> {}
"(Get, 2)" -> {"(List, 0)";"(Do, 0)";"(Accept, 2)";"(Get, 3)";"(Event, 4)";}
"(Bootstrap, 1)" -> {}
"(registerNodeVM, 5)" -> {"(Wait, 1)";}
"(checkCapacityAndRotate, 0)" -> {"(Publish, 1)";}
"(NewSourceFile, 4)" -> {}
"(list, 0)" -> {}
"(remove, 1)" -> {"(Remove, 2)";}
"(DecompressStream, 1)" -> {"(xzDecompress, 1)";}
"(MarshalIndent, 3)" -> {"(NewEncoder, 1)";}
"(WaitUntilFreshAndGet, 3)" -> {"(waitUntilFreshAndBlock, 2)";}
"(NewPerfCounterClient, 0)" -> {"(newClient, 1)";}
"(newClient, 1)" -> {"(startMonitoring, 0)";}
"(fulfill, 3)" -> {}
"(deriveKey, 9)" -> {"(processBlocks, 5)";}
"(scaleAllResources, 3)" -> {}
"(NonBlockingRun, 1)" -> {"(RunPostStartHooks, 1)";}
"(isContainerRunning, 1)" -> {"(runCommand, 2)";}
"(newMux, 1)" -> {}
"(ContainerExecAttach, 3)" -> {"(postHijacked, 5)";}
"(NodeAddresses, 2)" -> {"(Wait, 1)";"(Connect, 1)";}
"(getClientAndMasterVersions, 2)" -> {}
"(pushImage, 3)" -> {"(TarStream, 0)";"(NewCancelReadCloser, 2)";}
"(setup, 1)" -> {"(StartTestServerOrDie, 3)";}
"(NewSourceApiserver, 3)" -> {"(newSourceApiserverFromLW, 2)";}
"(Patch, 3)" -> {"(Do, 0)";}
"(digForNames, 2)" -> {"(Insert, 1)";}
"(newDelayingQueue, 2)" -> {}
"(Go, 1)" -> {}
"(addServiceOnPort, 4)" -> {"(ProxyLoop, 3)";}
"(cancelOnInterrupt, 2)" -> {}
"(GrabFromKubelet, 1)" -> {"(grabFromKubeletInternal, 2)";}
"(Check, 0)" -> {"(authenticateToMaster, 2)";"(runDiagnosticPod, 1)";"(authenticateToRegistry, 2)";"(connectAndResolve, 3)";"(resolveSearch, 3)";}
"(digForARecords, 2)" -> {"(Insert, 1)";}
"(NewHorizontalController, 9)" -> {"(NewNamedRateLimitingQueue, 2)";}
"(RoundTripOpt, 2)" -> {"(roundTrip, 1)";"(GetClientConn, 2)";}
"(StartControllers, 5)" -> {}
"(MonitorSize, 1)" -> {"(monitorSize, 2)";}
"(regexpMatch, 2)" -> {"(Init, 1)";}
"(scheduleFrameWrite, 0)" -> {"(startFrameWrite, 1)";}
"(Create, 0)" -> {"(CreateFromProvider, 1)";}
"(loadState, 0)" -> {"(clearState, 0)";}
"(AttachVolume, 2)" -> {"(WaitForAttachedDevice, 1)";}
"(initDevmapper, 1)" -> {"(initMetaData, 0)";}
"(sync, 1)" -> {"(deleteInstances, 1)";}
"(BuildMasterConfig, 2)" -> {"(NewPluginInitializer, 6)";"(NewAuthenticator, 3)";}
"(RunOnce, 1)" -> {"(runOnce, 2)";}
"(connectAndResolve, 3)" -> {"(dnsQueryWithTimeout, 3)";}
"(runTest, 1)" -> {"(runTestWithController, 3)";"(NewREST, 1)";"(NewREST, 2)";"(NewHorizontalController, 9)";}
"(ipsForEndpoints, 1)" -> {"(List, 0)";"(Insert, 1)";}
"(NewWatchBuffer, 1)" -> {}
"(addConnIfNeeded, 3)" -> {}
"(newTimeBudget, 1)" -> {}
"(Copy, 2)" -> {"(ServeHTTP, 2)";}
"(InstanceParentHierarchy, 1)" -> {"(InstanceToServiceClassAndPlan, 1)";}
"(processEvents, 1)" -> {"(Accept, 0)";}
"(WaitForRunningBuild, 3)" -> {}
"(pushV2Tag, 3)" -> {"(Upload, 3)";}
"(StorageWithCacher, 1)" -> {"(NewCacherFromConfig, 1)";}
"(CheckPodsRunningReady, 4)" -> {"(CheckPodsCondition, 6)";}
"(UpdatePod, 1)" -> {}
"(RetrieveClasses, 0)" -> {"(List, 1)";}
"(initRoutes, 0)" -> {"(Cancellable, 1)";}
"(ProxyLoop, 3)" -> {"(awaitAwakening, 4)";"(ProxyTCP, 2)";"(getBackendConn, 5)";"(proxyTCP, 2)";"(getBackendConn, 7)";}
"(Accept, 0)" -> {}
"(NewBroadcaster, 0)" -> {"(NewBroadcaster, 2)";}
"(reconcileNodeRoutes, 0)" -> {"(reconcile, 2)";}
"(frameHandler, 2)" -> {"(handleGoAwayFrame, 1)";}
"(postHijacked, 5)" -> {"(dial, 3)";}
"(startMetricsServer, 1)" -> {}
"(startMaster, 0)" -> {"(startServing, 2)";}
"(Stream, 1)" -> {"(stream, 1)";"(Negotiate, 4)";}
"(copyStdin, 0)" -> {}
"(, 0)" -> {"(CreateBatch, 1)";"(Update, 2)";"(RetrieveInstancesByPlan, 1)";"(OpenAPISchema, 0)";"(Delete, 1)";"(runResourceUsageTest, 3)";"(Decode, 3)";"(DumpNodeDebugInfo, 3)";"(Get, 2)";"(ensurePodsAreRemovedWhenNamespaceIsDeleted, 1)";"(Next, 0)";"(dumpObjectReadiness, 2)";"(RunRC, 1)";"(WaitForBindingCondition, 4)";"(DeleteNamespaces, 3)";"(Bootstrap, 1)";"(NewRecorder, 1)";"(DumpPodLogsStartingWith, 2)";"(Register, 2)";"(scaleAllResources, 3)";"(createTestController, 5)";"(Client, 1)";"(Search, 2)";"(CheckPodsRunningReadyOrSucceeded, 4)";"(Matches, 2)";"(PollUntil, 3)";"(WaitForInstanceCondition, 4)";"(doTestMustConnectSendDisconnect, 2)";"(testMulticast, 2)";"(WaitForSchedulerAfterAction, 4)";"(checkDockerNetworkServer, 0)";"(DoRaw, 0)";"(Watch, 1)";"(New, 0)";"(RetrieveBindings, 1)";"(RetrievePlanByName, 1)";"(NewKubectlCommand, 4)";"(GrabFromKubelet, 1)";"(Do, 1)";"(BeforeEach, 0)";"(Provision, 4)";"(Do, 0)";"(NewDynamicResourceConsumer, 11)";"(MarshalIndent, 3)";"(StartBuildAndWait, 2)";"(Signal, 1)";"(Output, 0)";"(Unbind, 4)";"(testRolloverDeployment, 1)";"(digForARecords, 2)";"(Close, 0)";"(runDensityTest, 2)";"(Execute, 0)";"(registerNodeVM, 5)";"(GetKubeletPods, 2)";"(curlUnix, 2)";"(ipsForEndpoints, 1)";"(VerifyPods, 5)";"(runDensityBatchTest, 5)";"(WaitForInstanceToNotExist, 3)";"(Run, 0)";"(Add, 1)";"(Server, 3)";"(Start, 1)";"(StartApiserverCPUProfileGatherer, 1)";"(CheckPodsRunningReady, 4)";"(DeleteVolume, 2)";"(digForSRVs, 2)";"(URL, 0)";"(checkDockerSeccomp, 0)";"(CloseNotify, 0)";"(runServiceLatencies, 3)";"(UpdateStatus, 1)";"(ExecOrDie, 0)";"(Pods, 1)";"(TestNotReachableUDP, 3)";"(RunImageChangeTriggerTest, 3)";"(scaleDown, 5)";"(ListHealthChecks, 0)";"(doTestMustConnectSendNothing, 2)";"(StringKeySet, 1)";"(Run, 1)";"(createAllResources, 3)";"(Read, 1)";"(WaitForBrokerCondition, 3)";"(Deprovision, 2)";"(Error, 0)";"(Init, 0)";"(Marshal, 1)";"(Provision, 6)";"(NewString, 1)";"(kill, 0)";"(RunScaleTest, 0)";"(RunBuildRunningPodDeleteTest, 3)";"(RetrievePlans, 0)";"(Union, 1)";"(extinguish, 4)";"(Exec, 0)";"(WithCancel, 1)";"(Encode, 1)";"(doTestConnectSendDisconnect, 2)";"(Suffix, 1)";"(checkDockerStorageDriver, 0)";"(Bind, 5)";"(testDeploymentCleanUpPolicy, 1)";"(run, 4)";"(run, 2)";"(Flush, 0)";"(CreatePods, 8)";"(WaitForClusterServiceClassToExist, 2)";"(run, 0)";"(Get, 0)";"(RunBuildConfigChangeControllerTest, 2)";"(CreateVolume, 2)";"(RetrieveClasses, 0)";"(RetrieveClassByName, 1)";"(New, 2)";"(RetrieveInstances, 1)";"(RunBuildControllerPodSyncTest, 3)";"(Stop, 0)";"(createBatchPodWithRateControl, 3)";"(WaitForBindingToNotExist, 3)";"(digForPTRRecords, 2)";"(Build, 0)";"(Receive, 2)";"(SubResource, 1)";"(Stream, 0)";"(NewSchemeBuilder, 1)";"(testZonalFailover, 2)";"(NewUnboundedExecutor, 0)";"(runUpgradeSuite, 7)";"(runTest, 1)";"(Parse, 1)";"(scaleUp, 5)";"(worker, 0)";"(testRollingUpdateDeployment, 1)";"(deletePodsSync, 2)";"(Errorf, 2)";"(gatherTestSuiteMetrics, 0)";"(TimedWaitForAnImageStreamTag, 5)";"(start, 1)";"(Remove, 1)";"(Process, 1)";"(Insert, 1)";"(checkDockerConfig, 0)";"(InstanceToServiceClassAndPlan, 1)";"(GetResource, 3)";"(Services, 1)";"(gatherMetrics, 1)";"(Start, 0)";"(ObserveNodeUpdateAfterAction, 4)";"(RetrieveBindingsByInstance, 1)";"(WaitForBrokerToNotExist, 2)";"(CreateKubeNamespace, 2)";"(RunBuildDeleteTest, 3)";"(fileServer, 2)";"(runDensitySeqTest, 4)";"(pathExistsInRegistry, 2)";"(Matches, 1)";"(RetrievePlansByClass, 1)";"(Parallelize, 3)";"(writeRemoteFile, 5)";"(Background, 0)";"(AbsPath, 1)";"(WaitForEndpoint, 3)";"(WaitForBuilderAccount, 1)";"(StartJenkinsMemoryTracking, 2)";"(PollImmediate, 3)";"(sshExec, 2)";"(getMasterSSHClient, 0)";"(Untar, 3)";"(deleteAllResources, 3)";"(testStackdriverAcceleratorMonitoring, 1)";"(Mkdir, 2)";"(AddObjectsToTemplate, 3)";"(OpenWebSocketForURL, 3)";"(run, 1)";"(InstanceParentHierarchy, 1)";"(isContainerRunning, 1)";"(Write, 1)";"(testProportionalScalingDeployment, 1)";"(RunBuildControllerTest, 3)";"(StartCmdAndStreamOutput, 1)";"(GetNodeInfo, 1)";"(IsRBACEnabled, 1)";"(Infof, 2)";"(Run, 2)";"(NewPodStore, 4)";"(Poll, 3)";"(sortAndDeduplicateRBACRulesFields, 1)";"(Deprovision, 3)";"(Create, 0)";"(restart, 0)";"(waitForInstanceToBeDeleted, 3)";"(ApplyLayer, 2)";"(Create, 1)";"(checkIPTables, 0)";"(New, 1)";"(waitTillNPodsRunningOnNodes, 6)";"(List, 0)";"(createClients, 1)";"(Describe, 2)";"(WriteString, 1)";"(Unbind, 2)";"(testReboot, 3)";"(CreateTemplates, 5)";"(setup, 0)";"(startLocalProxy, 0)";"(NodeAddresses, 2)";"(testNvidiaGPUsOnCOS, 1)";"(New, 3)";"(Find, 1)";"(String, 0)";"(tryEchoTCP, 1)";"(BuildInsecureClient, 1)";"(Format, 1)";"(curl, 1)";"(ExecWithOptions, 1)";"(WaitForAnImageStream, 4)";"(ReplicationControllers, 1)";"(NewNetworkingTestConfig, 1)";"(Sync, 0)";"(Query, 2)";"(newStaticTable, 0)";"(diskIsAttached, 2)";"(Bind, 6)";"(Delete, 2)";"(digForNames, 2)";"(CombinedOutput, 0)";"(List, 1)";"(WaitForClusterServiceClassToNotExist, 2)";"(IsPodSecurityPolicyEnabled, 1)";"(SimpleGET, 3)";"(Sync, 2)";"(preparePod, 4)";"(Delete, 0)";"(Update, 1)";"(Patch, 3)";"(AddImage, 3)";"(WaitForAnImageStreamTag, 4)";"(GetCodecForObject, 1)";"(digForCNAMEs, 2)";"(Catalog, 1)";"(RetrieveBrokers, 0)";"(RESTClient, 0)";"(AssertDeletedStorageFiles, 2)";}
"(Find, 1)" -> {"(Start, 0)";}
"(Deprovision, 2)" -> {"(Delete, 2)";}
"(WaitForAnImageStream, 4)" -> {"(Stop, 0)";"(Watch, 1)";}
"(syncLoop, 2)" -> {"(Watch, 0)";"(syncLoopIteration, 5)";}
"(ExecWithOptions, 1)" -> {"(execute, 7)";}
"(New, 2)" -> {"(runContainerdDaemon, 0)";"(startEventsMonitor, 0)";"(init, 0)";"(run, 0)";"(Dial, 2)";}
"(New, 5)" -> {"(NewNamedRateLimitingQueue, 2)";"(NewPerfCounterClient, 0)";"(NewServer, 2)";"(init, 0)";"(exportHTTP, 2)";"(configureKubeConfigForClientCertRotation, 2)";}
"(startPush, 1)" -> {}
"(newSerialImagePuller, 1)" -> {}
"(CalculateLayerChecksums, 3)" -> {}
"(MakeDefaultErrorFunc, 2)" -> {}
"(waitForAPIAndKubelet, 1)" -> {}
"(Client, 1)" -> {"(SetTransportDefaults, 1)";}
"(ExecInContainer, 8)" -> {"(HandleResizing, 2)";}
"(NewPodStore, 4)" -> {}
"(WaitForBuilderAccount, 1)" -> {"(Poll, 3)";}
"(diskIsAttached, 2)" -> {"(Connect, 2)";}
"(HandlePodCleanups, 0)" -> {"(cleanupOrphanedPodCgroups, 2)";}
"(ConfigureTransport, 1)" -> {"(configureTransport, 1)";}
"(RunInContainer, 3)" -> {"(ExecInContainer, 8)";"(ExecSync, 3)";}
"(makePodSourceConfig, 4)" -> {"(NewSourceFile, 4)";"(Channel, 1)";"(NewSourceURL, 5)";"(NewSourceApiserver, 3)";}
"(pullAndAck, 2)" -> {"(Pull, 2)";}
"(Watch, 1)" -> {"(Exists, 1)";"(Put, 3)";"(WatchList, 4)";"(Watch, 0)";}
"(printGraphBuildErrors, 1)" -> {"(getClientAndMasterVersions, 2)";}
"(RunDeployment, 1)" -> {"(start, 0)";}
"(PortForward, 4)" -> {"(PortForward, 3)";}
"(ContainerWait, 2)" -> {"(WaitStop, 1)";}
"(monitorNodeStatus, 0)" -> {}
"(doChecking, 0)" -> {"(UpdatePod, 1)";"(AddPod, 1)";}
"(Commit, 0)" -> {"(RegisterChange, 0)";}
"(exportLayer, 2)" -> {}
"(NewNamingConditionController, 2)" -> {"(NewNamedRateLimitingQueue, 2)";}
"(newContainerUploader, 3)" -> {}
"(WaitForClusterServiceClassToNotExist, 2)" -> {"(PollImmediate, 3)";}
"(startControllers, 3)" -> {"(RunSecurityAllocationController, 0)";}
"(startObservingCount, 1)" -> {}
"(RunDNS, 0)" -> {}
"(VerifyVolumesAreAttached, 2)" -> {"(GenerateBulkVolumeVerifyFunc, 4)";}
"(stream, 1)" -> {"(watchErrorStream, 2)";"(copyStdin, 0)";"(copyStdout, 1)";"(copyStderr, 1)";"(handleResizes, 0)";}
"(checkIPTables, 0)" -> {"(runCommand, 1)";}
"(Changes, 2)" -> {"(ChangesDirs, 2)";}
"(pullV2Tag, 2)" -> {"(pullSchema2, 3)";"(pullSchema1, 3)";}
"(Do, 0)" -> {"(tryThrottle, 0)";}
"(Watch, 0)" -> {"(NewStreamWatcher, 1)";}
"(startNewNode, 1)" -> {"(Dial, 2)";"(DaemonJoinsCluster, 1)";}
"(shutdown, 1)" -> {}
"(fileServer, 2)" -> {"(ServeHTTP, 2)";}
"(NewREST, 2)" -> {"(CompleteWithOptions, 1)";"(GetRESTOptions, 1)";}
"(Negotiate, 4)" -> {"(NewConnection, 1)";}
"(StartGatheringData, 0)" -> {}
"(NewCmdTop, 3)" -> {"(NewCmdTopNode, 3)";"(NewCmdTopPod, 3)";}
"(AddImage, 3)" -> {"(Insert, 1)";}
"(NewReferenceStore, 1)" -> {"(reload, 0)";}
"(executePreStopHook, 4)" -> {}
"(Execute, 0)" -> {"(Copy, 2)";"(Sync, 0)";}
"(digForSRVs, 2)" -> {"(Insert, 1)";}
"(containerUnpause, 1)" -> {"(Resume, 1)";}
"(NewRouter, 2)" -> {"(Cancellable, 1)";"(initRoutes, 0)";}
"(ToGenericInformer, 0)" -> {"(ForResource, 1)";}
"(awaitAwakening, 4)" -> {}
"(Server, 3)" -> {"(Serve, 1)";}
"(PrepullImagesInParallel, 2)" -> {}
"(NewCmdTopNode, 3)" -> {"(Bind, 1)";}
"(tlsDialWithDialer, 4)" -> {}
"(compress, 1)" -> {}
"(Now, 0)" -> {"(Add, 1)";}
"(doTestConnectSendDisconnect, 2)" -> {"(Dial, 2)";}
"(NewCmdCp, 3)" -> {"(runCopy, 5)";}
"(newClientConn, 2)" -> {}
"(Get, 1)" -> {"(getVolume, 1)";"(Call, 3)";"(locateArrayElement, 2)";"(NewString, 1)";"(Reset, 1)";"(getCredentialsFromStore, 1)";"(String, 0)";"(GetNode, 0)";"(Parse, 1)";"(GetByKey, 1)";"(Add, 1)";"(get, 1)";"(NewFromJSON, 1)";"(Prefix, 1)";"(Remove, 1)";"(IsValid, 0)";"(locateObjectField, 2)";"(GetPodStatus, 3)";"(New, 1)";"(Get, 2)";"(getInternal, 1)";"(Index, 1)";"(Replace, 4)";"(Now, 0)";"(ReturnIterator, 1)";"(ListPodStats, 0)";"(Close, 0)";"(Unlock, 0)";"(After, 1)";"(Set, 1)";"(Get, 0)";}
"(Index, 1)" -> {"(Search, 2)";}
"(streamPathToBuild, 8)" -> {"(Checkout, 2)";}
"(Next, 0)" -> {"(Copy, 2)";}
"(configureTransport, 1)" -> {"(addConnIfNeeded, 3)";}
"(NewPriorityFrameQueue, 1)" -> {"(Init, 1)";}
"(ListGroups, 0)" -> {"(QueryForEntries, 2)";}
"(startEndpointWatcher, 2)" -> {}
"(syncProxyRules, 0)" -> {"(SyncServices, 1)";}
"(RunBuildControllerPodSyncTest, 3)" -> {"(Watch, 1)";"(Stop, 0)";}
"(PollImmediate, 3)" -> {"(poller, 2)";}
"(acquire, 0)" -> {"(maybeReportTransition, 0)";}
"(RunPostStartHooks, 1)" -> {}
"(Type2, 1)" -> {"(Load, 1)";"(wrapType, 1)";}
"(Connect, 1)" -> {"(NewManager, 1)";}
"(runWithOutput, 0)" -> {"(ContainerLogs, 4)";}
"(CopyFileWithTar, 2)" -> {"(Go, 1)";}
"(run, 3)" -> {"(ContainerExecStart, 5)";}
"(collect, 1)" -> {"(typeCheck, 2)";}
"(DeleteNamespaces, 3)" -> {}
"(Accept, 2)" -> {"(Accept, 0)";}
"(Marshal, 1)" -> {"(NewEncoder, 1)";"(marshalDoc, 2)";}
"(DaemonLeavesCluster, 0)" -> {"(setClusterProvider, 1)";}
"(Init, 0)" -> {"(startPollingLogs, 0)";"(waitSinkInit, 0)";}
"(pullSchema1, 3)" -> {"(Download, 4)";}
"(StartReaper, 0)" -> {}
"(initForOS, 1)" -> {"(InitService, 1)";}
"(gc, 0)" -> {"(gcTerminated, 1)";}
"(Skip, 0)" -> {"(Token, 0)";}
"(GetContainerLogs, 5)" -> {"(Logs, 3)";}
}

```

Leave a reaction on this issue to contribute to the project by classifying this instance as a **Bug** :-1:, **Mitigated** :+1:, or **Desirable Behavior** :rocket:
See the descriptions of the classifications [here](https://github.com/github-vet/rangeclosure-findings#how-can-i-help) for more information.

commit ID: bba4ecd772d120ba795d0d4d3f70db0b0bd0c508