* 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**.

            if (thread != null) {
                Runtime.getRuntime().removeShutdownHook(thread);
            }
        } catch (IllegalStateException e) {
            // When shutting down is in progress, invocation of this method throws exception,
            // interrupting other shutdown hooks, so we catch it here.
            //
            // Caused by: java.lang.IllegalStateException: Shutdown in progress

    public void uncaughtException(Thread t, Throwable e) {
      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the

	if err != nil {
		log.Errorf("Local %s DNS server terminated: %v", p.protocol, err)
	}
}

func (p *dnsProxy) close() {
	if p.server != nil {
		if err := p.server.Shutdown(); err != nil {
			log.Errorf("error in shutting down %s dns downstreamUDPServer :%v", p.protocol, err)
		}
	}
}

func (p *dnsProxy) Address() string {
	if p.server != nil {
		if p.server.Listener != nil {
			return p.server.Listener.Addr().String()
		}

		TearDownConnection: true,
		Message:            "The apiserver is shutting down, please try again later.",
	}

	// NOTE: both WithRetryAfter and WithWaitGroup must use the same exact isRequestExemptFunc 'isRequestExemptFromRetryAfter,
	// otherwise SafeWaitGroup might wait indefinitely and will prevent the server from shutting down gracefully.

		SetExitStatus(2)
		Exit()
	}
	return toolPath
}

// ToolPath returns the path at which we expect to find the named tool
// (for example, "vet"), and the error (if any) from statting that path.
func ToolPath(toolName string) (string, error) {
	toolPath := filepath.Join(build.ToolDir, toolName) + cfg.ToolExeSuffix()
	err := toolStatCache.Do(toolPath, func() error {
		_, err := os.Stat(toolPath)