kc = kclient.NewUntypedInformer(cl.client, gvr, filter)
	} else {
		kc = kclient.NewDelayedInformer[controllers.Object](
			cl.client,
			gvr,
			kubetypes.StandardInformer,
			filter,
		)
	}

	kind := s.Kind()
	kc.AddEventHandler(controllers.EventHandler[controllers.Object]{
		AddFunc: func(obj controllers.Object) {
			incrementEvent(kind, "add")
			cl.queue.Push(func() error {

	}

	// TODO: Handle overlapping controllers better. Either disallow them at admission time or
	// deterministically avoid syncing controllers that fight over pods. Currently, we only
	// ensure that the same controller is synced for a given pod. When we periodically relist
	// all controllers there will still be some replica instability. One way to handle this is
	// by querying the store for all controllers that this rc overlaps, as well as all

		return fmt.Errorf("error initializing config controller: %v", err)
	}
	if err := s.initServiceControllers(args); err != nil {
		return fmt.Errorf("error initializing service controllers: %v", err)
	}
	return nil
}

func (s *Server) initNodeUntaintController(args *PilotArgs) {
	s.addStartFunc("nodeUntainter controller", func(stop <-chan struct{}) error {
		go leaderelection.

- `kube-controller-manager` and `cloud-controller-manager` have changed the
  name of controllers that can be turned on/off that are passed to the `--controllers`
  flag (e.g., `pod-garbage-collector-controller`). The old names (eg `podgc`) are

    @Override
    public Map<String, List<SomeToolingModel>> execute(BuildController controller) {
        GradleBuild buildModel = controller.getBuildModel();
        Map<String, List<SomeToolingModel>> result = new LinkedHashMap<>();
        for (String parameter : parameters) {
            Map<String, SomeToolingModel> model = fetchSomeModelForAllProjects(controller, buildModel, parameter);

- The `horizontalpodautoscaling` and `clusterrole-aggregation` controllers now assume the `autoscaling/v1` and `rbac.authorization.k8s.io/v1` APIs are available. If you disable those APIs and do not want to run those controllers, exclude them by passing `--controllers=-horizontalpodautoscaling` or `--controllers=-clusterrole-aggregation` to `kube-controller-manager`. ([#117977](https://github.com/kubernetes/kubernetes/pull/117977), [@liggitt](https://github.com/liggitt))...

#   DOCKER_REGISTRY
function start-cloud-controller-manager {
  echo "Start cloud provider controller-manager"
  setup-addon-manifests "addons" "cloud-controller-manager"

  create-kubeconfig "cloud-controller-manager" "${CLOUD_CONTROLLER_MANAGER_TOKEN}"
  echo "Preparing cloud provider controller-manager log file"
  prepare-log-file /var/log/cloud-controller-manager.log "${CLOUD_CONTROLLER_MANAGER_RUNASUSER:-0}"

    @Override
    public CustomModel execute(BuildController controller) {
        EclipseProject eclipseProject = controller.getModel(EclipseProject.class);
        GradleProject gradleProject = controller.getModel(GradleProject.class);

        // Intentionally sending models in an order different from requesting models
        controller.send(gradleProject);
        controller.send(eclipseProject);

        return new CustomModel(42);
    }

		f:    i.inf.HasSynced,
	}
}

func informerEventHandler[I controllers.ComparableObject](handler func(o Event[I], initialSync bool)) cache.ResourceEventHandler {
	return controllers.EventHandler[I]{
		AddExtendedFunc: func(obj I, initialSync bool) {
			handler(Event[I]{
				New:   &obj,
				Event: controllers.EventAdd,
			}, initialSync)
		},
		UpdateFunc: func(oldObj, newObj I) {

    @Override
    public Result execute(BuildController controller) {
        Result result = new Result();

        GradleBuild buildModel = controller.getBuildModel();
        result.rootBuild = buildModel;
        result.rootIdeaProject = controller.getModel(IdeaProject.class);

        collectAllNestedBuilds(buildModel, controller, result);

        result.allIdeaProjects.add(result.rootIdeaProject);