com.palantir.atlasdb.timelock.api.management.UndertowTimeLockManagementService Maven / Gradle / Ivy

Go to download
package com.palantir.atlasdb.timelock.api.management;

import com.google.common.util.concurrent.ListenableFuture;
import com.palantir.logsafe.Safe;
import com.palantir.tokens.auth.AuthHeader;
import java.util.Set;
import java.util.UUID;
import javax.annotation.processing.Generated;

@Generated("com.palantir.conjure.java.services.UndertowServiceInterfaceGenerator")
public interface UndertowTimeLockManagementService {
    /**
     * The endpoint loads all persisted namespaces. leaderPaxos is filtered out from the set
     * as it is not a namespace. No transactionality guarantees are given: namespace additions and
     * deletions while the request is running may or may not be reflected in the output.
     * @apiNote {@code POST /tl/management/getNamespaces}
     */
    ListenableFuture> getNamespaces(AuthHeader authHeader);

    /**
     * The endpoint loads all namespaces with new timestamps since the last restart.
     * leaderPaxos is filtered out from the set as it is not a namespace.
     * @apiNote {@code POST /tl/management/getActiveNamespaces}
     */
    ListenableFuture> getActiveNamespaces(AuthHeader authHeader);

    /**
     * The operation of achieving consensus on all namespaces is NOT atomic. In the case of failures, it can
     * be assumed that consensus was achieved on some namespaces.
     * @apiNote {@code POST /tl/management/achieveConsensus}
     */
    ListenableFuture achieveConsensus(AuthHeader authHeader, @Safe Set namespaces);

    /**
     * Invalidates existing resources for a given TimeLock namespace in a persistant way, until re-enabled. Does not
     * actually cause a leader election, and should not interrupt service for other naemspaces. Note that this
     * operation is atomic for each namespace (e.g. users will not see two different lock services servicing the
     * same startTransactions request), but not atomic as a whole. Additionally, if this method throws, it is
     * nondeterministic which, if any, namespaces have been invalidated; some may even be invalidated only on a
     * subset of nodes. This state can be cleared by re-enabling all namespaces.
     * @apiNote {@code POST /tl/management/invalidateResources}
     */
    ListenableFuture invalidateResources(AuthHeader authHeader, @Safe Set namespaces);

    /**
     * Gets the randomly generated server id associated with the server's current lifecycle upon start up.
     * @apiNote {@code POST /tl/management/getServerLifecycleId}
     */
    ListenableFuture getServerLifecycleId(AuthHeader authHeader);

    /**
     * Kills TimeLock server asynchronously i.e. current server will not be able to talk to
     * peer nodes or serve requests once the task is executed. After hitting this endpoint, the server will require
     * external intervention to start up the service again. The endpoint returns the (randomly generated) server id
     * associated with server upon start up. A client can then make getServerId requests wherein change in
     * server id would imply that the server was bounced.
     * @apiNote {@code POST /tl/management/forceKillTimeLockServer}
     */
    ListenableFuture forceKillTimeLockServer(AuthHeader authHeader);
}