log.Warnf("Error in invoking drain listeners endpoint: %v", err)
	}
	// If we drained now, skip draining + waiting later
	// When we terminate, we will instead exit immediately
	a.DisableDraining()
}

// terminate starts exiting the process.
func (a *Agent) terminate() {
	log.Infof("Agent draining Proxy for termination")
	if a.skipDrain.Load() {
		log.Infof("Agent already drained, exiting immediately")

    }

    public static enum TypeVisitResult {
        /**
         * Continue visiting.
         */
        CONTINUE,

        /**
         * Terminate visiting immediately.
         */
        TERMINATE
    }

	}
}

func TestGet(t *testing.T) {
	storage, _, _, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)
	test.TestGet(validNewPod())
}

func TestList(t *testing.T) {
	storage, _, _, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.Store.DestroyFunc()
	test := genericregistrytest.New(t, storage.Store)

	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.CustomResource.Store.DestroyFunc()
	test := registrytest.New(t, storage.CustomResource.Store)
	cr := validNewCustomResource()
	cr.SetNamespace("")
	test.TestCreate(
		cr,
	)
}

func TestGet(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)
	defer storage.CustomResource.Store.DestroyFunc()

    /**
     * Continue visiting. When returned after visiting a directory,
     * the entries in the directory will be visited next.
     */
    CONTINUE,

    /**
     * Terminate visiting immediately.
     */
    TERMINATE,

    /**
     * If returned from visiting a directory, the directories entries will not be visited;
     * otherwise works as {@link #CONTINUE}.
     */
    SKIP_SUBTREE

func TestEmpty(t *testing.T) {
	storage, server, _, _ := newStorage(t)
	defer server.Terminate(t)
	if _, err := storage.Allocate(1); !strings.Contains(err.Error(), "cannot allocate resources of type serviceipallocations at this time") {
		t.Fatal(err)
	}
}

func TestStore(t *testing.T) {
	storage, server, backing, config := newStorage(t)
	defer server.Terminate(t)

# A script that let's gci preemptible nodes gracefully terminate in the event of a VM shutdown.
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"

                visitor.leaveDirectory(this);
                return CONTINUE;
            case SKIP_SUBTREE:
                return CONTINUE;
            case TERMINATE:
                return SnapshotVisitResult.TERMINATE;
            default:
                throw new AssertionError();
        }
    }

    @Override

        given:
        def requestReceived = false
        def terminate = false
        setupLockOwner {
            requestReceived = true
            while(!terminate) { Thread.sleep(100) } //block the release action thread
        }

        when:
        def build = executer.withTasks("lock").start()

        then: 0 * _
    }

    def "can terminate type hierarchy walk"() {
        def visitor = Mock(Types.TypeVisitor)
        when:
        Types.walkTypeHierarchy(Child, [Object, GroovyObject], visitor)

        then: 1 * visitor.visitType(Child) >> Types.TypeVisitResult.CONTINUE
        then: 1 * visitor.visitType(Base) >> Types.TypeVisitResult.TERMINATE
        then: 0 * _
    }