Module org.elasticsearch.server
Package org.elasticsearch.snapshots

Class SnapshotsService

java.lang.Object
org.elasticsearch.common.component.AbstractLifecycleComponent
org.elasticsearch.snapshots.SnapshotsService
All Implemented Interfaces:
Closeable, AutoCloseable, ClusterStateApplier, LifecycleComponent, Releasable
public final class SnapshotsService extends AbstractLifecycleComponent implements ClusterStateApplier
Service responsible for creating snapshots. This service runs all the steps executed on the master node during snapshot creation and deletion. See package level documentation of org.elasticsearch.snapshots for details. See SnapshotShardsService for the data node snapshotting steps.

  • Field Details

    • SHARD_GEN_IN_REPO_DATA_VERSION

      public static final IndexVersion SHARD_GEN_IN_REPO_DATA_VERSION

    • INDEX_GEN_IN_REPO_DATA_VERSION

      public static final IndexVersion INDEX_GEN_IN_REPO_DATA_VERSION

    • UUIDS_IN_REPO_DATA_VERSION

      public static final IndexVersion UUIDS_IN_REPO_DATA_VERSION

    • UUIDS_IN_REPO_DATA_TRANSPORT_VERSION

      public static final TransportVersion UUIDS_IN_REPO_DATA_TRANSPORT_VERSION

    • FILE_INFO_WRITER_UUIDS_IN_SHARD_DATA_VERSION

      public static final IndexVersion FILE_INFO_WRITER_UUIDS_IN_SHARD_DATA_VERSION

    • OLD_SNAPSHOT_FORMAT

      public static final IndexVersion OLD_SNAPSHOT_FORMAT

    • POLICY_ID_METADATA_FIELD

      public static final String POLICY_ID_METADATA_FIELD
      See Also:

    • UPDATE_SNAPSHOT_STATUS_ACTION_NAME

      public static final String UPDATE_SNAPSHOT_STATUS_ACTION_NAME
      See Also:

    • NO_FEATURE_STATES_VALUE

      public static final String NO_FEATURE_STATES_VALUE
      See Also:

    • MAX_CONCURRENT_SNAPSHOT_OPERATIONS_SETTING

      public static final Setting<Integer> MAX_CONCURRENT_SNAPSHOT_OPERATIONS_SETTING
      Setting that specifies the maximum number of allowed concurrent snapshot create and delete operations in the cluster state. The number of concurrent operations in a cluster state is defined as the sum of SnapshotsInProgress.count() and the size of SnapshotDeletionsInProgress.getEntries().

  • Constructor Details

  • Method Details

    • executeSnapshot

      public void executeSnapshot(CreateSnapshotRequest request, ActionListener<SnapshotInfo> listener)
      Same as createSnapshot(CreateSnapshotRequest, ActionListener) but invokes its callback on completion of the snapshot.
      Parameters:
      request - snapshot request
      listener - snapshot completion listener

    • createSnapshot

      public void createSnapshot(CreateSnapshotRequest request, ActionListener<Snapshot> listener)
      Initializes the snapshotting process.

      This method is used by clients to start snapshot. It makes sure that there is no snapshots are currently running and creates a snapshot record in cluster state metadata.

      Parameters:
      request - snapshot request
      listener - snapshot creation listener

    • cloneSnapshot

      public void cloneSnapshot(CloneSnapshotRequest request, ActionListener<Void> listener)

    • ensureRepositoryExists

      public static void ensureRepositoryExists(String repoName, ClusterState state)
      Throws RepositoryMissingException if no repository by the given name is found in the given cluster state.

    • currentSnapshots

      public static List<SnapshotsInProgress.Entry> currentSnapshots(@Nullable SnapshotsInProgress snapshotsInProgress, String repository, List<String> snapshots)
      Returns status of the currently running snapshots

      This method is executed on master node

      Parameters:
      snapshotsInProgress - snapshots in progress in the cluster state
      repository - repository id
      snapshots - list of snapshots that will be used as a filter, empty list means no snapshots are filtered
      Returns:
      list of metadata for currently running snapshots

    • applyClusterState

      public void applyClusterState(ClusterChangedEvent event)
      Description copied from interface: ClusterStateApplier
      Called when a new cluster state (ClusterChangedEvent.state() needs to be applied. The cluster state to be applied is already committed when this method is called, so an applier must therefore be prepared to deal with any state it receives without throwing an exception. Throwing an exception from an applier is very bad because it will stop the application of this state before it has reached all the other appliers, and will likely result in another attempt to apply the same (or very similar) cluster state which might continue until this node is removed from the cluster.

      Cluster states are applied one-by-one which means they can be a performance bottleneck. Implementations of this method should therefore be fast, so please consider forking work into the background rather than doing everything inline.

      Specified by:
      applyClusterState in interface ClusterStateApplier

    • stateWithoutSnapshot

      public static ClusterState stateWithoutSnapshot(ClusterState state, Snapshot snapshot, ShardGenerations shardGenerations)
      Computes the cluster state resulting from removing a given snapshot create operation from the given state. This method will update the shard generations of snapshots that the given snapshot depended on so that finalizing them will not cause rolling back to an outdated shard generation.

      For example, shard snapshot X can be taken, but not finalized yet. Shard snapshot Y can then depend upon shard snapshot X. Then shard snapshot Y may finalize before shard snapshot X, but including X. However, X does not include Y. Therefore we update X to use Y's shard generation file (list of snapshots and dependencies) to avoid overwriting with X's file that is missing Y.

      Parameters:
      state - current cluster state
      snapshot - snapshot for which to remove the snapshot operation
      Returns:
      updated cluster state

    • deleteSnapshots

      public void deleteSnapshots(DeleteSnapshotRequest request, ActionListener<Void> listener)
      Deletes snapshots from the repository. In-progress snapshots matched by the delete will be aborted before deleting them. When wait_for_completion is set to true, the passed action listener will only complete when all matching snapshots are deleted, when it is false it will complete as soon as the deletes are scheduled
      Parameters:
      request - delete snapshot request
      listener - listener a listener which will be resolved according to the wait_for_completion parameter

    • minCompatibleVersion

      public static IndexVersion minCompatibleVersion(IndexVersion minNodeVersion, RepositoryData repositoryData, @Nullable Collection<SnapshotId> excluded)
      Determines the minimum IndexVersion that the snapshot repository must be compatible with from the current nodes in the cluster and the contents of the repository. The minimum version is determined as the lowest version found across all snapshots in the repository and all nodes in the cluster.
      Parameters:
      minNodeVersion - minimum node version in the cluster
      repositoryData - current RepositoryData of that repository
      excluded - snapshot id to ignore when computing the minimum version (used to use newer metadata version after a snapshot delete)
      Returns:
      minimum node version that must still be able to read the repository metadata

    • useShardGenerations

      public static boolean useShardGenerations(IndexVersion repositoryMetaVersion)
      Checks whether the metadata version supports writing ShardGenerations to the repository.
      Parameters:
      repositoryMetaVersion - version to check
      Returns:
      true if version supports ShardGenerations

    • useIndexGenerations

      public static boolean useIndexGenerations(IndexVersion repositoryMetaVersion)
      Checks whether the metadata version supports writing ShardGenerations to the repository.
      Parameters:
      repositoryMetaVersion - version to check
      Returns:
      true if version supports ShardGenerations

    • includesUUIDs

      public static boolean includesUUIDs(IndexVersion repositoryMetaVersion)
      Checks whether the metadata version supports writing the cluster- and repository-uuid to the repository.
      Parameters:
      repositoryMetaVersion - version to check
      Returns:
      true if version supports writing cluster- and repository-uuid to the repository

    • includeFileInfoWriterUUID

      public static boolean includeFileInfoWriterUUID(IndexVersion repositoryMetaVersion)

    • updateWithSnapshots

      public static ClusterState updateWithSnapshots(ClusterState state, @Nullable SnapshotsInProgress snapshotsInProgress, @Nullable SnapshotDeletionsInProgress snapshotDeletionsInProgress)
      Shortcut to build new ClusterState from the current state and updated values of SnapshotsInProgress and SnapshotDeletionsInProgress.
      Parameters:
      state - current cluster state
      snapshotsInProgress - new value for SnapshotsInProgress or null if it's unchanged
      snapshotDeletionsInProgress - new value for SnapshotDeletionsInProgress or null if it's unchanged
      Returns:
      updated cluster state

    • snapshottingDataStreams

      public static Set<String> snapshottingDataStreams(ClusterState currentState, Set<String> dataStreamsToCheck)
      Returns the data streams that are currently being snapshotted (with partial == false) and that are contained in the indices-to-check set.

    • snapshottingIndices

      public static Set<Index> snapshottingIndices(ClusterState currentState, Set<Index> indicesToCheck)
      Returns the indices that are currently being snapshotted (with partial == false) and that are contained in the indices-to-check set.

    • doStart

      protected void doStart()
      Description copied from class: AbstractLifecycleComponent
      Start this component. Typically that means doing things like launching background processes and registering listeners on other components. Other components have been initialized by this point, but may not yet be started.

      If this method throws an exception then the startup process will fail, but this component will not be stopped before it is closed.

      This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is only called once in the lifetime of a component, although it may not be called at all if the startup process encountered some kind of fatal error, such as the failure of some other component to initialize or start.

      Specified by:
      doStart in class AbstractLifecycleComponent

    • doStop

      protected void doStop()
      Description copied from class: AbstractLifecycleComponent
      Stop this component. Typically that means doing the reverse of whatever AbstractLifecycleComponent.doStart() does.

      This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is only called once in the lifetime of a component, after calling AbstractLifecycleComponent.doStart(), although it will not be called at all if this component did not successfully start.

      Specified by:
      doStop in class AbstractLifecycleComponent

    • doClose

      protected void doClose()
      Description copied from class: AbstractLifecycleComponent
      Close this component. Typically that means doing the reverse of whatever happened during initialization, such as releasing resources acquired there.

      This method is called while synchronized on AbstractLifecycleComponent.lifecycle. It is called once in the lifetime of a component. If the component was started then it will be stopped before it is closed, and once it is closed it will not be started or stopped.

      Specified by:
      doClose in class AbstractLifecycleComponent

    • assertAllListenersResolved

      public boolean assertAllListenersResolved()
      Assert that no in-memory state for any running snapshot-create or -delete operation exists in this instance.