result, err := kl.runOnce(ctx, u.Pods, runOnceRetryDelay)
		klog.InfoS("Finished processing pods", "numPods", len(u.Pods))
		return result, err
	case <-time.After(runOnceManifestDelay):
		return nil, fmt.Errorf("no pod manifest update after %v", runOnceManifestDelay)
	}
}

// runOnce runs a given set of pods and returns their status.

		RequestHeaderAuthRequestController: requestHeaderAuthRequestController,
	}, nil
}

func (c *DynamicRequestHeaderController) RunOnce(ctx context.Context) error {
	errs := []error{}
	errs = append(errs, c.ConfigMapCAController.RunOnce(ctx))
	errs = append(errs, c.RequestHeaderAuthRequestController.RunOnce(ctx))
	return errors.NewAggregate(errs)
}

func (c *DynamicRequestHeaderController) Run(ctx context.Context, workers int) {

    queue.schedule("task", TimeUnit.MILLISECONDS.toNanos(750)) {
      log.put("runOnce delays.size=${delays.size}")
      return@schedule delays.removeAt(0)
    }

    assertThat(log.take()).isEqualTo("runOnce delays.size=2")
    val t2 = System.nanoTime() / 1e6 - t1
    assertThat(t2).isCloseTo(750.0, 250.0)

    assertThat(log.take()).isEqualTo("runOnce delays.size=1")
    val t3 = System.nanoTime() / 1e6 - t1

		curr.AddListener(listener)
	}
}

// AddListener adds a listener to be notified when the CA content changes.
func (c unionCAContent) RunOnce(ctx context.Context) error {
	errors := []error{}
	for _, curr := range c {
		if controller, ok := curr.(ControllerRunner); ok {
			if err := controller.RunOnce(ctx); err != nil {
				errors = append(errors, err)
			}
		}
	}

	return utilerrors.NewAggregate(errors)
}

	MinimumGCAge:			s.MinimumGCAge,
	MaxPerPodContainerCount:	s.MaxPerPodContainerCount,
	MaxContainerCount:		s.MaxContainerCount,
	ClusterDomain:			s.ClusterDomain,
	ClusterDNS:			s.ClusterDNS,
	Runonce:			s.RunOnce,
	Port:				s.Port,
	ReadOnlyPort:			s.ReadOnlyPort,
	CadvisorInterface:		cadvisorInterface,
	EnableServer:			s.EnableServer,
	EnableDebuggingHandlers:	s.EnableDebuggingHandlers,

    MaxContainerCount:              s.MaxContainerCount,
    ClusterDomain:                  s.ClusterDomain,
    ClusterDNS:                     s.ClusterDNS,
    Runonce:                        s.RunOnce,
    Port:                           s.Port,
    ReadOnlyPort:                   s.ReadOnlyPort,
    CadvisorInterface:              cadvisorInterface,
    EnableServer:                   s.EnableServer,

 */
package okhttp3.internal.concurrent

/**
 * A unit of work that can be executed one or more times.
 *
 * Recurrence
 * ----------
 *
 * Tasks control their recurrence schedule. The [runOnce] function returns -1L to signify that the
 * task should not be executed again. Otherwise it returns a delay until the next execution.
 *

var FileRefreshDuration = 1 * time.Minute

// ControllerRunner is a generic interface for starting a controller
type ControllerRunner interface {
	// RunOnce runs the sync loop a single time.  This useful for synchronous priming
	RunOnce(ctx context.Context) error

	// Run should be called a go .Run
	Run(ctx context.Context, workers int)
}

   */
  fun schedule(
    name: String,
    delayNanos: Long = 0L,
    block: () -> Long,
  ) {
    schedule(
      object : Task(name) {
        override fun runOnce(): Long {
          return block()
        }
      },
      delayNanos,
    )
  }

  /**
   * Executes [block] once on a task runner thread.
   *

	// because runonce is never used in kubernetes now, we should deprioritize the cleanup work.
	// TODO(random-liu) Fix the test, make it meaningful.
	fakeRuntime.PodStatus = kubecontainer.PodStatus{
		ContainerStatuses: []*kubecontainer.Status{
			{
				Name:  "bar",
				State: kubecontainer.ContainerStateRunning,
			},
		},
	}
	results, err := kb.runOnce(ctx, pods, time.Millisecond)
	if err != nil {