val currentThread = Thread.currentThread()
    val oldName = currentThread.name
    currentThread.name = task.name

    var delayNanos = -1L
    try {
      delayNanos = task.runOnce()
    } finally {
      lock.withLock {
        afterRun(task, delayNanos)
      }
      currentThread.name = oldName
    }
  }

  private fun afterRun(
    task: Task,
    delayNanos: Long,

				MaxPods:                          0,
				PodCIDR:                          "",
				PodPidsLimit:                     utilpointer.Int64(0),
				ResolverConfig:                   utilpointer.String(""),
				RunOnce:                          false,
				CPUCFSQuota:                      utilpointer.Bool(false),
				CPUCFSQuotaPeriod:                &zeroDuration,
				NodeStatusMaxImages:              utilpointer.Int32(0),

		"ProviderID",
		"ReadOnlyPort",
		"RegisterNode",
		"RegistryBurst",
		"RegistryPullQPS",
		"ReservedMemory",
		"ReservedSystemCPUs",
		"RegisterWithTaints",
		"RuntimeRequestTimeout.Duration",
		"RunOnce",
		"SeccompDefault",
		"SerializeImagePulls",
		"MaxParallelImagePulls",
		"ShowHiddenMetricsForVersion",
		"ShutdownGracePeriodByPodPriority[*].Priority",

	fs.StringVar(&c.ResolverConfig, "resolv-conf", c.ResolverConfig, "Resolver configuration file used as the basis for the container DNS resolution configuration.")

	fs.BoolVar(&c.RunOnce, "runonce", c.RunOnce, "If true, exit after spawning pods from static pod files or remote urls. Exclusive with --enable-server")

    val source: BufferedSource,
    val sink: BufferedSink,
  ) : Closeable {
    abstract fun cancel()
  }

  private inner class WriterTask : Task("$name writer") {
    override fun runOnce(): Long {
      try {
        if (writeOneFrame()) return 0L
      } catch (e: IOException) {
        failWebSocket(e = e, isWriter = true)
      }
      return -1L
    }
  }

	// ResolverConfig is the resolver configuration file used as the basis
	// for the container DNS resolution configuration.
	ResolverConfig string
	// RunOnce causes the Kubelet to check the API server once for pods,
	// run those in addition to the pods specified by static pod files, and exit.
	RunOnce bool
	// cpuCFSQuota enables CPU CFS quota enforcement for containers that
	// specify CPU limits
	CPUCFSQuota bool

				err := r.ipAddressStore.Add(ip)
				if err != nil {
					t.Errorf("Unexpected error trying to add IPAddress %s object: %v", ip, err)
				}
			}

			err = r.runOnce()
			if err != nil {
				t.Fatal(err)
			}

			for _, ip := range test.expectedIPs {
				_, err := r.ipAddressLister.Get(ip)
				if err != nil {

   */
  private var nextSequenceNumber: Long = 0

  private val cleanupQueue = taskRunner.newQueue()
  private val cleanupTask =
    object : Task("$okHttpName Cache") {
      override fun runOnce(): Long {
        synchronized(this@DiskLruCache) {
          if (!initialized || closed) {
            return -1L // Nothing to do.
          }

          try {
            trimToSize()

HSPLokhttp3/internal/concurrent/Task;-><init>(Ljava/lang/String;ZI)V
HSPLokhttp3/internal/concurrent/TaskQueue$execute$1;-><init>(Ljava/lang/String;ZLkotlin/jvm/functions/Function0;)V
HSPLokhttp3/internal/concurrent/TaskQueue$execute$1;->runOnce()J
HSPLokhttp3/internal/concurrent/TaskQueue;-><init>(Lokhttp3/internal/concurrent/TaskRunner;Ljava/lang/String;)V
HSPLokhttp3/internal/concurrent/TaskQueue;->cancelAllAndDecide$okhttp()Z

			// in this case, the container should not to into waiting state immediately because that can make cases like runonce pods actually run
			// twice. "container never ran" is different than "container ran and failed".  This is handled differently in the kubelet