fi
  echo "${short_hash:0:10}"
}

# Pedantically kill, wait-on and remove a container. The -f -v options
# to rm don't actually seem to get the job done, so force kill the
# container, wait to ensure it's stopped, then try the remove. This is
# a workaround for bug https://github.com/docker/docker/issues/3968.
function kube::build::destroy_container() {
  "${DOCKER[@]}" kill "$1" >/dev/null 2>&1 || true

		increase monotonically.

	/sched/pauses/stopping/gc:seconds
		Distribution of individual GC-related stop-the-world stopping
		latencies. This is the time it takes from deciding to stop the
		world until all Ps are stopped. This is a subset of the total
		GC-related stop-the-world time (/sched/pauses/total/gc:seconds).
		During this time, some threads may be executing. Bucket counts
		increase monotonically.

	disablethp: setting disablethp=1 on Linux disables transparent huge pages for the heap.
	It has no effect on other platforms. disablethp is meant for compatibility with versions
	of Go before 1.21, which stopped working around a Linux kernel default that can result
	in significant memory overuse. See https://go.dev/issue/64332. This setting will be
	removed in a future release, so operators should tweak their Linux configuration to suit

					},
				},
				ObjectMeta: metav1.ObjectMeta{
					CreationTimestamp: metav1.Time{Time: defaultTestTime},
				},
			},
			wantFinishTime: defaultTestTime,
		},
		// In this case, init container is stopped after the regular containers.
		// This is because with the sidecar (restartable init) containers,
		// sidecar containers will always finish later than regular containers.

			// For all other unhandled errors we exit and fail.
			return nil, nil, err
		}

		select {
		case <-ticker.C:
		case <-globalOSSignalCh:
			return nil, nil, fmt.Errorf("Initializing data volumes gracefully stopped")
		}
	}

type healStatusSummary string

// healStatusSummary constants
const (
	healNotStartedStatus healStatusSummary = "not started"
	healRunningStatus                      = "running"
	healStoppedStatus                      = "stopped"
	healFinishedStatus                     = "finished"
)

const (
	// a heal sequence with this many un-consumed heal result
	// items blocks until heal-status consumption resumes or is
	// aborted due to timeout.

			if inGC[g] || bgMark[g] {
				if !old.Executing() && new.Executing() {
					// Started running while doing GC things.
					ps[ev.Proc()].gc++
				} else if old.Executing() && !new.Executing() {
					// Stopped running while doing GC things.
					ps[ev.Proc()].gc--
				}
			}
			states[g] = new
		case EventLabel:
			l := ev.Label()

	// are registered (in n.registeredHandlers); this can cause the dynamic filtering to miss events
	reg, err := n.informer.AddEventHandler(fh)
	if err != nil {
		// Should only happen if its already stopped. We should exit early.
		return
	}
	n.registeredHandlers = append(n.registeredHandlers, handlerRegistration{registration: reg, handler: h})
}

func (n *informerClient[T]) HasSynced() bool {

	ln, err := net.Listen("tcp", insecureServer.Addr)
	if err != nil {
		t.Errorf("failed to listen on %v: %v", insecureServer.Addr, err)
	}

	// get port
	serverPort := ln.Addr().(*net.TCPAddr).Port
	stoppedCh, _, err := RunServer(insecureServer, ln, 10*time.Second, stopCh)
	if err != nil {
		t.Fatalf("RunServer err: %v", err)
	}

	graceCh := make(chan struct{})
	// mock a client request
	go func() {

			return nil
		}
	}
	return getg()
}

// sigtrampgo is called from the signal handler function, sigtramp,
// written in assembly code.
// This is called by the signal handler, and the world may be stopped.
//
// It must be nosplit because getg() is still the G that was running
// (if any) when the signal was delivered, but it's (usually) called
// on the gsignal stack. Until this switches the G to gsignal, the