}
    }

    @Override
    public void stopNow() {
        lock.lock();
        try {
            aborted = true;
            if (connection != null) {
                connection.abort();
            }
        } finally {
            lock.unlock();

            // cleanup() will abort the process as desired
            cleanup();
        }
    }

    public void setExecHandle(ExecHandle execHandle) {

 * <h3>State flows</h3>
 *
 * <ul>
 *   <li>INIT -&gt; STARTED -&gt; [SUCCEEDED|FAILED|ABORTED|DETACHED]</li>
 *   <li>INIT -&gt; FAILED</li>
 *   <li>INIT -&gt; STARTED -&gt; DETACHED -&gt; ABORTED</li>
 * </ul>
 *
 * State is controlled on all control methods:
 * <ul>
 * <li>{@link #start()} allowed when state is INIT</li>
 * <li>{@link #abort()} allowed when state is STARTED or DETACHED</li>
 * </ul>
 */

package main

func main() {
	defer func() {
		// This recover recovers the panic caused by the nil defer func
		// g(). The original panic(1) was already aborted/replaced by this
		// new panic, so when this recover is done, the program completes
		// normally.
		recover()
	}()
	f()
}

func f() {
	var g func()
	defer g()
	panic(1)

    private final boolean abort;

    public DataStoreCrawlingException(final String url, final String message, final Exception e) {
        this(url, message, e, false);
    }

    public DataStoreCrawlingException(final String url, final String message, final Exception e, final boolean abort) {
        super(message, e);
        this.url = url;
        this.abort = abort;
    }

    public String getUrl() {

 * limitations under the License.
 */

package org.gradle.process.internal;

public enum ExecHandleState {
    INIT(false),
    STARTING(false),
    STARTED(false),
    ABORTED(true),
    FAILED(true),
    DETACHED(true),
    SUCCEEDED(true);

    private final boolean terminal;

    ExecHandleState(boolean terminal) {
        this.terminal = terminal;
    }

// The dialer reduces the TIME-WAIT period to 1 seconds instead of the OS default of 60 seconds.
// Using 1 second instead of 0 because SO_LINGER socket option to 0 causes pending data to be
// discarded and the connection to be aborted with an RST rather than for the pending data to be
// transmitted and the connection closed cleanly with a FIN.
// Ref: https://issues.k8s.io/89898
func ProbeDialer() *net.Dialer {
	dialer := &net.Dialer{

        if (failure instanceof GradleException) {
            throw (GradleException) failure;
        }
        if (failure != null) {
            throw new GradleException(action + " aborted because of an internal error.", failure);
        }
        return this;
    }

// The dialer reduces the TIME-WAIT period to 1 seconds instead of the OS default of 60 seconds.
// Using 1 second instead of 0 because SO_LINGER socket option to 0 causes pending data to be
// discarded and the connection to be aborted with an RST rather than for the pending data to be
// transmitted and the connection closed cleanly with a FIN.
// Ref: https://issues.k8s.io/89898
func ProbeDialer() *net.Dialer {
	dialer := &net.Dialer{

// The dialer reduces the TIME-WAIT period to 1 seconds instead of the OS default of 60 seconds.
// Using 1 second instead of 0 because SO_LINGER socket option to 0 causes pending data to be
// discarded and the connection to be aborted with an RST rather than for the pending data to be
// transmitted and the connection closed cleanly with a FIN.
// Ref: https://issues.k8s.io/89898
func ProbeDialer() *net.Dialer {
	dialer := &net.Dialer{

// The dialer reduces the TIME-WAIT period to 1 seconds instead of the OS default of 60 seconds.
// Using 1 second instead of 0 because SO_LINGER socket option to 0 causes pending data to be
// discarded and the connection to be aborted with an RST rather than for the pending data to be
// transmitted and the connection closed cleanly with a FIN.
// Ref: https://issues.k8s.io/89898
func ProbeDialer() *net.Dialer {
	dialer := &net.Dialer{