// NOTE: both WithWaitGroup and WithRetryAfter must use the same exact isRequestExemptFunc 'isRequestExemptFromRetryAfter,
	// otherwise SafeWaitGroup might wait indefinitely and will prevent the server from shutting down gracefully.
	return withWaitGroup(handler, longRunning, wg, isRequestExemptFromRetryAfter)
}

			// When apiserver is shutting down, signal clients to retry
			// There is a good chance the client hit a different server, so a tight retry is good for client responsiveness.
			waitGroupWriteRetryAfterToResponse(w)
			return
		}

		// attach ServerShutdownSignal to the watch request so that the
		// watch handler loop can return as soon as the server signals
		// that it is shutting down.

#ifndef VERSION
#define VERSION HEAD
#endif

BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
{
	switch (fdwCtrlType)
	{
	case CTRL_C_EVENT:
		fprintf(stderr, "Shutting down, got signal\n");
		exit(0);

	case CTRL_BREAK_EVENT:
		fprintf(stderr, "Shutting down, got signal\n");
		exit(0);

	default:
		return FALSE;
	}
}

int main(int argc, char **argv)
{
	int i;
	for (i = 1; i < argc; ++i)
	{

			// This is used to verify that we don't wait for it while shutting down.
			c:     newFakeComponent(longDuration, stop),
			async: false,
			wait:  false,
		},
		{
			name: "RunComponentAsync",
			// Use a large duration - it will not complete before the end of the test.
			// This is used to verify that we don't wait for it while shutting down.
			c:     newFakeComponent(longDuration, stop),
			async: true,

//go:build go1.20

package main

import (
	"os"
	"os/exec"
	"time"
)

func cmdInterrupt(cmd *exec.Cmd) {
	cmd.Cancel = func() error {
		// On timeout, send interrupt,
		// in hopes of shutting down process tree.
		// Ignore errors sending signal; it's all best effort
		// and not even implemented on Windows.
		// TODO(rsc): Maybe use a new process group and kill the whole group?
		cmd.Process.Signal(os.Interrupt)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.tooling.internal.protocol;

/**
 * The parameters for shutting down a provider connection.
 *
 * <p>This is a marker interface. Instances are queried dynamically to see which parameters they support.
 *
 * @since 2.2-rc-1
 */

    interface BuildScanResult {

    }

    interface Listener {
        /**
         * Called after all user build logic has completed and the build outcome reported to the logging system. Also called prior to shutting down the build(-tree) scope services
         */
        BuildScanResult execute(BuildResult buildResult);
    }

    void notify(Listener listener);

preemptible=$(curl "http://metadata.google.internal/computeMetadata/v1/instance/scheduling/preemptible" -H "Metadata-Flavor: Google")
if [ "${preemptible}" == "TRUE" ]; then
    echo "Shutting down! Sleeping for a minute to let the node gracefully terminate"
    # https://cloud.google.com/compute/docs/instances/stopping-or-deleting-an-instance#delete_timeout
    sleep 30

package net

import (
	"bytes"
	"syscall"
	"testing"
	"time"
)

// Test that a client can't trigger an endless loop of write system
// calls on the server by shutting down the write side on the client.
// Possibility raised in the discussion of https://golang.org/cl/71973.
func TestEndlessWrite(t *testing.T) {
	t.Parallel()
	c := make(chan bool)
	server := func(cs *TCPConn) error {

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.