pub struct NotifyStore {
pub id: Uuid,
pub disk_map: HashMap<usize, Vec<Option<Arc<Disk>>>>,
pub pools: Vec<Arc<Sets>>,
pub peer_sys: S3PeerSys,
pub pool_meta: RwLock<PoolMeta>,
pub rebalance_meta: RwLock<Option<RebalanceMeta>>,
pub decommission_cancelers: RwLock<Vec<Option<DecommissionCanceler>>>,
/* private fields */
}Fields§
§id: Uuid§disk_map: HashMap<usize, Vec<Option<Arc<Disk>>>>§pools: Vec<Arc<Sets>>§peer_sys: S3PeerSys§pool_meta: RwLock<PoolMeta>§rebalance_meta: RwLock<Option<RebalanceMeta>>§decommission_cancelers: RwLock<Vec<Option<DecommissionCanceler>>>Implementations§
Source§impl ECStore
impl ECStore
pub async fn inspect_legacy_transition_state( &self, selector: LegacyTransitionStateReconcileSelector, ) -> Result<LegacyTransitionStateReconcileResponse, LegacyTransitionStateReconcileError>
pub async fn reconcile_legacy_transition_state( &self, request: LegacyTransitionStateReconcileRequest, ) -> Result<LegacyTransitionStateReconcileResponse, LegacyTransitionStateReconcileError>
Source§impl ECStore
impl ECStore
pub async fn load_heal_lifecycle_expiry_context( &self, bucket: &str, ) -> Result<Option<HealLifecycleExpiryContext>, StorageError>
pub async fn enqueue_heal_lifecycle_expiry( self: &Arc<ECStore>, context: &HealLifecycleExpiryContext, bucket: &str, object: &str, version_id: Option<&str>, object_info: Option<&ObjectInfo>, ) -> Result<bool, StorageError>
Sourcepub async fn pool_meta_writes_ready(&self) -> bool
pub async fn pool_meta_writes_ready(&self) -> bool
Reports whether pool metadata side effects are currently writable. Read-only admission probes do not change this state; startup and real metadata transactions still latch it on unrecoverable conditions.
Sourcepub async fn pool_meta_write_gate_status(&self) -> PoolMetaWriteGateStatus
pub async fn pool_meta_write_gate_status(&self) -> PoolMetaWriteGateStatus
A health probe must not wait behind a metadata transaction’s disk I/O.
Sourcepub async fn pool_meta_write_status(&self) -> Result<(), StorageError>
pub async fn pool_meta_write_status(&self) -> Result<(), StorageError>
A health probe must not wait behind a metadata transaction’s disk I/O.
pub async fn status(&self, idx: usize) -> Result<PoolStatus, StorageError>
pub async fn refresh_pool_status_meta(&self) -> Result<(), StorageError>
pub async fn decommission_cancel( self: &Arc<ECStore>, idx: usize, ) -> Result<(), StorageError>
pub async fn clear_decommission( self: &Arc<ECStore>, idx: usize, ) -> Result<(), StorageError>
pub async fn is_decommission_running(&self) -> bool
pub async fn spawn_missing_local_decommission_routines( self: &Arc<ECStore>, ) -> Result<(), StorageError>
pub async fn decommission( &self, rx: CancellationToken, indices: Vec<usize>, ) -> Result<(), StorageError>
pub async fn do_decommission_in_routine( self: &Arc<ECStore>, canceler: DecommissionCanceler, idx: usize, entry_budget: Arc<Semaphore>, ) -> Result<(), StorageError>
pub async fn decommission_failed(&self, idx: usize) -> Result<(), StorageError>
pub async fn complete_decommission( &self, idx: usize, ) -> Result<(), StorageError>
pub async fn start_decommission( &self, indices: Vec<usize>, ) -> Result<(), StorageError>
Source§impl ECStore
impl ECStore
pub async fn load_rebalance_meta(&self) -> Result<(), StorageError>
Sourcepub async fn prepare_rebalance_stop(
&self,
) -> Result<Option<String>, StorageError>
pub async fn prepare_rebalance_stop( &self, ) -> Result<Option<String>, StorageError>
Cancels local admission before refreshing the persisted stop target under the start gate.
pub async fn refresh_rebalance_status_meta(&self) -> Result<(), StorageError>
pub async fn update_rebalance_stats(&self) -> Result<(), StorageError>
pub async fn init_rebalance_meta( &self, bucktes: Vec<String>, ) -> Result<String, StorageError>
pub async fn init_and_start_rebalance( self: &Arc<ECStore>, bucktes: Vec<String>, ) -> Result<String, StorageError>
pub async fn init_rebalance_start( self: &Arc<ECStore>, bucktes: Vec<String>, ) -> Result<String, StorageError>
pub async fn start_rebalance_for_id( self: &Arc<ECStore>, expected_id: &str, ) -> Result<(), StorageError>
pub async fn rollback_rebalance_start_for_id( self: &Arc<ECStore>, expected_id: Option<&str>, start_error: String, ) -> Result<(), StorageError>
pub async fn update_pool_stats( &self, pool_index: usize, bucket: String, fi: &FileInfo, ) -> Result<(), StorageError>
pub async fn update_pool_stats_batch( &self, pool_index: usize, bucket: String, versions: &[&FileInfo], ) -> Result<(), StorageError>
pub async fn next_rebal_bucket( &self, pool_index: usize, expected_id: &str, ) -> Result<Option<String>, StorageError>
pub async fn bucket_rebalance_done( &self, pool_index: usize, bucket: String, expected_id: &str, ) -> Result<(), StorageError>
pub async fn is_rebalance_started(&self) -> bool
pub async fn is_rebalance_conflicting_with_decommission(&self) -> bool
pub async fn is_pool_rebalancing(&self, pool_index: usize) -> bool
pub async fn pool_rebalance_status( &self, pool_index: usize, ) -> (RebalStatus, bool)
pub async fn current_rebalance_id(&self) -> Option<String>
pub async fn cancel_rebalance_admission_for_id( &self, expected_id: &str, ) -> Result<(), StorageError>
pub async fn stop_rebalance(self: &Arc<ECStore>) -> Result<(), StorageError>
pub async fn stop_rebalance_for_id( self: &Arc<ECStore>, expected_id: Option<&str>, ) -> Result<(), StorageError>
pub async fn record_rebalance_stop_propagation( self: &Arc<ECStore>, expected_id: &str, record: RebalanceStopPropagationRecord, ) -> Result<(), StorageError>
Source§impl ECStore
impl ECStore
pub async fn start_rebalance(self: &Arc<ECStore>) -> Result<(), StorageError>
Source§impl ECStore
impl ECStore
pub async fn save_rebalance_stats( &self, pool_idx: usize, opt: RebalSaveOpt, ) -> Result<(), StorageError>
pub async fn save_rebalance_stats_for_id( &self, pool_idx: usize, opt: RebalSaveOpt, expected_id: &str, ) -> Result<(), StorageError>
Source§impl ECStore
impl ECStore
pub async fn get_bucket_metadata( &self, bucket: &str, ) -> Result<Arc<BucketMetadata>, StorageError>
pub async fn get_bucket_policy( &self, bucket: &str, ) -> Result<(BucketPolicy, OffsetDateTime), StorageError>
pub async fn get_bucket_policy_raw( &self, bucket: &str, ) -> Result<(String, OffsetDateTime), StorageError>
pub async fn restricts_public_bucket_access( &self, bucket: &str, ) -> Result<bool, StorageError>
pub async fn update_bucket_metadata_config( &self, bucket: &str, config_file: &str, data: Vec<u8>, ) -> Result<OffsetDateTime, StorageError>
pub async fn bucket_incarnation_id( &self, bucket: &str, ) -> Result<Uuid, StorageError>
pub async fn bucket_incarnation_id_from_disk( &self, bucket: &str, ) -> Result<Uuid, StorageError>
Sourcepub async fn acquire_bucket_incarnation_fence(
&self,
bucket: &str,
expected: Uuid,
) -> Result<BucketIncarnationFenceGuard, StorageError>
pub async fn acquire_bucket_incarnation_fence( &self, bucket: &str, expected: Uuid, ) -> Result<BucketIncarnationFenceGuard, StorageError>
Acquire the bucket lifecycle read lock and validate the bucket
incarnation against expected, memoizing the validation while this
node keeps continuous read-lock coverage (see [super::bucket_fence]).
Semantics are identical to the pre-existing per-PUT
acquire_bucket_lifecycle_read_lock + from-disk
validate_bucket_incarnation pair: the first PUT in a coverage window
performs exactly that authoritative disk validation; overlapping PUTs
reuse its result, which is sound because bucket deletion/recreation
requires the lifecycle WRITE lock and therefore cannot have run while
any read guard was continuously held.
Sourcepub async fn lock_bucket_for_recursive_delete(
&self,
bucket: &str,
) -> Result<NamespaceLockGuard, StorageError>
pub async fn lock_bucket_for_recursive_delete( &self, bucket: &str, ) -> Result<NamespaceLockGuard, StorageError>
Hold this guard through recursive-delete authorization and mutation so writers cannot introduce an unchecked object into the deletion scope.
pub async fn list_bucket_for_scanner( &self, opts: &BucketOptions, ) -> Result<ScannerBucketListing, StorageError>
Source§impl ECStore
impl ECStore
pub async fn purge_delete_marker_with_proof( self: &Arc<ECStore>, bucket: &str, object: &str, version_id: &str, purge: &MrfDeleteMarkerPurge, opts: &HealOpts, ) -> Result<bool, StorageError>
pub async fn heal_bucket_at_incarnation( self: &Arc<ECStore>, bucket: &str, expected: Uuid, opts: &HealOpts, ) -> Result<HealResultItem, StorageError>
pub async fn heal_local_bucket_at_incarnation( self: &Arc<ECStore>, bucket: &str, expected: Uuid, opts: &HealOpts, fenced_pools: Vec<usize>, pools: Option<Vec<usize>>, ) -> Result<HealResultItem, StorageError>
pub async fn heal_object_at_incarnation( self: &Arc<ECStore>, bucket: &str, object: &str, version_id: &str, expected: Uuid, opts: &HealOpts, ) -> Result<HealObjectStorageResult, StorageError>
Sourcepub fn replacement_pool_metadata_required(
&self,
pool_index: usize,
set_index: usize,
) -> Result<bool, StorageError>
pub fn replacement_pool_metadata_required( &self, pool_index: usize, set_index: usize, ) -> Result<bool, StorageError>
Whether a replacement set owns this pool’s pool.bin replica.
Placement is determined by the same hash as metadata writes, never by
whether a shard is currently readable on the replacement disk.
Sourcepub async fn heal_erasure_set_scopes(
&self,
opts: &HealOpts,
) -> Result<Vec<(usize, usize)>, StorageError>
pub async fn heal_erasure_set_scopes( &self, opts: &HealOpts, ) -> Result<Vec<(usize, usize)>, StorageError>
Return every live erasure set selected by an object-heal scope.
pub async fn heal_replacement_format( &self, dry_run: bool, pool_index: usize, set_index: usize, targets: &[String], ) -> Result<(HealResultItem, Option<StorageError>), StorageError>
pub async fn replacement_targets_have_version( &self, bucket: &str, object: &str, version_id: &str, pool_index: usize, set_index: usize, targets: &[String], ) -> Result<bool, StorageError>
pub async fn heal_object_with_proof( &self, bucket: &str, object: &str, version_id: &str, opts: &HealOpts, ) -> Result<HealObjectStorageResult, StorageError>
Source§impl ECStore
impl ECStore
Sourcepub async fn heal_walk_versions_page(
&self,
pool_idx: usize,
set_idx: usize,
bucket: &str,
prefix: &str,
forward_to: Option<&str>,
batch_objects: usize,
version_budget: usize,
include_lifecycle_object_info: bool,
) -> Result<(Vec<HealWalkVersion>, Option<String>, bool), StorageError>
pub async fn heal_walk_versions_page( &self, pool_idx: usize, set_idx: usize, bucket: &str, prefix: &str, forward_to: Option<&str>, batch_objects: usize, version_budget: usize, include_lifecycle_object_info: bool, ) -> Result<(Vec<HealWalkVersion>, Option<String>, bool), StorageError>
Walk a specific erasure set’s disks and return one page of the cross-disk
UNION of versions (see SetDisks::heal_walk_versions_page). pool_idx and
set_idx are bounds-checked against the live pool topology.
Source§impl ECStore
impl ECStore
Sourcepub fn background_cancel_token(&self) -> Option<CancellationToken>
pub fn background_cancel_token(&self) -> Option<CancellationToken>
Shutdown token owned by this store instance.
Sourcepub fn validate_startup_storage_class(
endpoint_pools: &EndpointServerPools,
) -> Result<(), StorageError>
pub fn validate_startup_storage_class( endpoint_pools: &EndpointServerPools, ) -> Result<(), StorageError>
Validate topology and process storage-class overrides before any disk is opened.
pub async fn new( address: SocketAddr, endpoint_pools: EndpointServerPools, ctx: CancellationToken, ) -> Result<Arc<ECStore>, StorageError>
Sourcepub async fn new_with_instance_ctx(
address: SocketAddr,
endpoint_pools: EndpointServerPools,
ctx: CancellationToken,
instance_ctx: Arc<InstanceContext>,
) -> Result<Arc<ECStore>, StorageError>
pub async fn new_with_instance_ctx( address: SocketAddr, endpoint_pools: EndpointServerPools, ctx: CancellationToken, instance_ctx: Arc<InstanceContext>, ) -> Result<Arc<ECStore>, StorageError>
Build a store around an explicit instance context (Phase 5 follow-up,
backlog#1052). The legacy ECStore::new entry adopts the process
bootstrap context, keeping single-instance startup byte-for-byte
unchanged; a caller that owns its own context (a future second embedded
server) passes it here so every construction-time write — pool sets,
local-disk registry, deployment id — lands on that context instead of
the shared bootstrap one.
pub async fn init( self: &Arc<ECStore>, rx: CancellationToken, ) -> Result<(), StorageError>
pub fn init_local_disks()
pub fn single_pool(&self) -> bool
Sourcepub fn supports_atomic_create_only_write_back(&self) -> bool
pub fn supports_atomic_create_only_write_back(&self) -> bool
The set-local create-only check is atomic only when every object mutation uses that same, enabled namespace lock domain.
Source§impl ECStore
impl ECStore
pub async fn inner_list_objects_v2( self: Arc<ECStore>, bucket: &str, prefix: &str, continuation_token: Option<String>, delimiter: Option<String>, max_keys: i32, _fetch_owner: bool, start_after: Option<String>, incl_deleted: bool, ) -> Result<ListObjectsV2Info<ObjectInfo>, StorageError>
pub async fn list_objects_generic( self: Arc<ECStore>, bucket: &str, prefix: &str, marker: Option<String>, delimiter: Option<String>, max_keys: i32, incl_deleted: bool, ) -> Result<ListObjectsInfo<ObjectInfo>, StorageError>
pub async fn inner_list_object_versions( self: Arc<ECStore>, bucket: &str, prefix: &str, marker: Option<String>, version_marker: Option<String>, delimiter: Option<String>, max_keys: i32, ) -> Result<ListObjectVersionsInfo<ObjectInfo>, StorageError>
pub async fn list_path( self: Arc<ECStore>, o: &ListPathOptions, ) -> Result<MetaCacheEntriesSortedResult, StorageError>
pub async fn walk_internal( self: Arc<ECStore>, rx: CancellationToken, bucket: &str, prefix: &str, result: Sender<ObjectInfoOrErr<ObjectInfo, StorageError>>, opts: WalkOptions<fn(&FileInfo) -> bool>, ) -> Result<(), StorageError>
Source§impl ECStore
impl ECStore
pub async fn list_multipart_uploads_for_bucket_incarnation( &self, bucket: &str, prefix: &str, key_marker: Option<String>, upload_id_marker: Option<String>, delimiter: Option<String>, max_uploads: usize, expected_incarnation_id: Uuid, ) -> Result<ListMultipartsInfo, StorageError>
Source§impl ECStore
impl ECStore
Sourcepub async fn object_lock_config_snapshot(
&self,
bucket: &str,
) -> Result<Arc<ObjectLockConfigSnapshot>, StorageError>
pub async fn object_lock_config_snapshot( &self, bucket: &str, ) -> Result<Arc<ObjectLockConfigSnapshot>, StorageError>
Captures Object Lock state once for a batch of PUTs to the same bucket.
handle_put_object only reuses the token for the same store, bucket,
bucket incarnation, and Object Lock configuration revision.
Sourcepub async fn prepare_select_object_snapshot(
&self,
bucket: &str,
object: &str,
headers: &HeaderMap,
opts: &ObjectOptions,
) -> Result<SelectObjectSnapshot, PrepareSelectObjectSnapshotError>
pub async fn prepare_select_object_snapshot( &self, bucket: &str, object: &str, headers: &HeaderMap, opts: &ObjectOptions, ) -> Result<SelectObjectSnapshot, PrepareSelectObjectSnapshotError>
Resolves a GET’s object identity without constructing its body reader.
This is an additive two-stage counterpart to get_object_reader. The
existing method remains the compatibility path for callers that do not
need a pre-reader decision point.
pub async fn prepare_get_object_reader( &self, bucket: &str, object: &str, range: Option<HTTPRangeSpec>, headers: HeaderMap, opts: &ObjectOptions, ) -> Result<PreparedGetObjectReader, StorageError>
Sourcepub async fn acquire_restore_accept_guard(
&self,
bucket: &str,
object: &str,
) -> Result<RestoreAcceptGuard, StorageError>
pub async fn acquire_restore_accept_guard( &self, bucket: &str, object: &str, ) -> Result<RestoreAcceptGuard, StorageError>
Serializes the RestoreObject accept path — the read of the current
x-amz-restore status, the ongoing/already-restored decision, and the
metadata write that flips ongoing-request="true" — against concurrent
accepts of the same object, making that read-check-write an atomic
compare-and-set (backlog#1304). While the guard is held the caller must
pass no_lock: true on its reads/writes of this object, check
[RestoreAcceptGuard::is_lock_lost] before the status write, and drop
the guard before starting the tier copy-back so concurrent
HEAD/get_object_info stay non-blocking during the restore.
Sourcepub async fn acquire_restore_worker_guard(
&self,
operation_id: Uuid,
) -> Result<RestoreWorkerGuard, StorageError>
pub async fn acquire_restore_worker_guard( &self, operation_id: Uuid, ) -> Result<RestoreWorkerGuard, StorageError>
Acquire the liveness lock for a newly generated restore UUID using the normal namespace-lock timeout. New generations cannot legitimately contend, but a distributed quorum can take longer than the short orphan probe window under load.
Sourcepub async fn try_acquire_restore_worker_guard(
&self,
operation_id: Uuid,
) -> Result<Option<RestoreWorkerGuard>, StorageError>
pub async fn try_acquire_restore_worker_guard( &self, operation_id: Uuid, ) -> Result<Option<RestoreWorkerGuard>, StorageError>
Probe the liveness lock for an already-persisted restore UUID.
Contention is returned as None; infrastructure/quorum failures remain
typed errors so callers fail closed instead of reaping an active worker.
Sourcepub async fn save_scanner_pause_backlog_replica(
self: &Arc<ECStore>,
pool_index: usize,
set_index: usize,
data: Vec<u8>,
preconditions: HTTPPreconditions,
) -> Result<ObjectInfo, StorageError>
pub async fn save_scanner_pause_backlog_replica( self: &Arc<ECStore>, pool_index: usize, set_index: usize, data: Vec<u8>, preconditions: HTTPPreconditions, ) -> Result<ObjectInfo, StorageError>
Publish a native scanner replica without allowing stale pool selection to race retirement. Failed/canceled membership repair remains permitted. A canceled waiter cannot release publication fences from an in-flight write.
Sourcepub async fn get_object_reader_for_copy(
&self,
bucket: &str,
object: &str,
range: Option<HTTPRangeSpec>,
h: HeaderMap,
opts: &ObjectOptions,
) -> Result<(GetObjectReader, CancellationToken), StorageError>
pub async fn get_object_reader_for_copy( &self, bucket: &str, object: &str, range: Option<HTTPRangeSpec>, h: HeaderMap, opts: &ObjectOptions, ) -> Result<(GetObjectReader, CancellationToken), StorageError>
Open a source reader for a server-side copy.
Copy consumers hold the source reader while a destination write can
apply backpressure. Keep that read contract explicit at the storage
boundary so the lower-level legacy multipart pipeline can suppress its
speculative next-part setup without changing the public ObjectIO
trait or ObjectOptions layout.
Sourcepub async fn get_object_info_for_delete(
&self,
bucket: &str,
object: &str,
opts: &ObjectOptions,
) -> Result<ObjectInfo, StorageError>
pub async fn get_object_info_for_delete( &self, bucket: &str, object: &str, opts: &ObjectOptions, ) -> Result<ObjectInfo, StorageError>
Return metadata for DELETE preflight, including an explicitly addressed
delete marker. GET/HEAD may also use this metadata-only lookup to enrich
an already failed read with marker headers, never to serve marker data.
Normal reads must keep using get_object_info; authorization and Object
Lock enforcement still belong to the caller and locked delete.
pub async fn delete_object_with_tier_delete_journal( self: &Arc<ECStore>, bucket: &str, object: &str, opts: ObjectOptions, ) -> Result<ObjectInfo, StorageError>
pub async fn delete_objects_with_tier_delete_journal( self: &Arc<ECStore>, bucket: &str, objects: Vec<ObjectToDelete>, opts: ObjectOptions, ) -> (Vec<DeletedObject>, Vec<Option<StorageError>>)
pub async fn delete_objects_with_tier_delete_journal_and_accounting( self: &Arc<ECStore>, bucket: &str, objects: Vec<ObjectToDelete>, opts: ObjectOptions, ) -> (Vec<DeletedObject>, Vec<Option<StorageError>>, Vec<Option<DeleteAccounting>>)
Source§impl ECStore
impl ECStore
pub async fn write_local_metadata_at_incarnation( self: &Arc<ECStore>, disk_ref: &str, target: (&str, &str), fi: FileInfo, expected: Uuid, ) -> Result<(), DiskError>
pub async fn delete_local_path_at_incarnation( self: &Arc<ECStore>, disk_ref: &str, target: (&str, &str), opts: DeleteOptions, expected: Uuid, ) -> Result<(), DiskError>
pub async fn delete_local_version_at_incarnation( &self, disk_ref: &str, target: (&str, &str), fi: FileInfo, force_del_marker: bool, opts: DeleteOptions, expected: Uuid, ) -> Result<(), DiskError>
Sourcepub async fn rename_local_data_at_incarnation(
&self,
disk_ref: &str,
source: (&str, &str),
fi: &FileInfo,
destination: (&str, &str),
expected: Uuid,
) -> Result<RenameDataResp, DiskError>
pub async fn rename_local_data_at_incarnation( &self, disk_ref: &str, source: (&str, &str), fi: &FileInfo, destination: (&str, &str), expected: Uuid, ) -> Result<RenameDataResp, DiskError>
Target-side admission for an incarnation-bound heal rename. The physical namespace operations retain the lifecycle owner after RPC cancellation.
Sourcepub async fn rename_local_data(
&self,
disk_ref: &str,
source: (&str, &str),
fi: &FileInfo,
destination: (&str, &str),
scanner_token: Option<Uuid>,
) -> Result<RenameDataResp, DiskError>
pub async fn rename_local_data( &self, disk_ref: &str, source: (&str, &str), fi: &FileInfo, destination: (&str, &str), scanner_token: Option<Uuid>, ) -> Result<RenameDataResp, DiskError>
Execute on this instance’s active local disk through the physical owner.
pub async fn undo_local_write( &self, disk_ref: &str, volume: &str, path: &str, fi: FileInfo, opts: DeleteOptions, ) -> Result<(), DiskError>
Source§impl ECStore
impl ECStore
Sourcepub async fn reload_pool_meta(&self) -> Result<bool, StorageError>
pub async fn reload_pool_meta(&self) -> Result<bool, StorageError>
Peer reload entry: refreshes in-memory pool metadata from the shared persisted snapshot. Returns whether newer state was actually merged so callers only trigger missing-worker recovery after a real state change; delayed snapshots are merged monotonically and never blind-assigned.
Source§impl ECStore
Phase 2: Accessor methods for config globals
These delegate to the process-global statics. No local state — the globals
remain the single source of truth until the migration is complete.
impl ECStore
Phase 2: Accessor methods for config globals These delegate to the process-global statics. No local state — the globals remain the single source of truth until the migration is complete.
Sourcepub fn all_set_disks(&self) -> Vec<Arc<SetDisks>>
pub fn all_set_disks(&self) -> Vec<Arc<SetDisks>>
Every erasure set across all pools, pool-major order.
Read-only queries that must consult each set’s own copy of a
per-bucket object (e.g. the scanner’s .usage-cache.bin) iterate
this instead of the hash-routed store path, which would always land
on one set (rustfs/backlog#1872).
Sourcepub async fn scanner_pause_backlog_writable_set_disks(
&self,
) -> Vec<Arc<SetDisks>>
pub async fn scanner_pause_backlog_writable_set_disks( &self, ) -> Vec<Arc<SetDisks>>
Erasure sets that may receive scanner pause-backlog replicas.
An actively decommissioning or already decommissioned source pool is excluded so an operational record acknowledged during movement always has a copy on storage that remains in the cluster. The record is kept separate from pool and rebalance metadata.
Sourcepub fn get_server_config(&self) -> Option<Config>
pub fn get_server_config(&self) -> Option<Config>
Get server configuration (delegates to global)
Sourcepub fn set_server_config(&self, cfg: Config)
pub fn set_server_config(&self, cfg: Config)
Set server configuration (delegates to global)
Sourcepub fn get_storage_class(&self) -> Option<Config>
pub fn get_storage_class(&self) -> Option<Config>
Get storage class configuration (delegates to global)
Sourcepub fn set_storage_class(&self, cfg: Config)
pub fn set_storage_class(&self, cfg: Config)
Set storage class configuration (delegates to global)
Source§impl ECStore
Phase 3: Accessor methods for service globals
These provide a unified API through ECStore for accessing cross-cutting
service singletons. The globals remain the source of truth.
impl ECStore
Phase 3: Accessor methods for service globals These provide a unified API through ECStore for accessing cross-cutting service singletons. The globals remain the source of truth.
Sourcepub fn notification_system(&self) -> Option<Arc<NotificationSys>>
pub fn notification_system(&self) -> Option<Arc<NotificationSys>>
Get the notification system
Sourcepub fn bucket_metadata_sys(&self) -> Option<Arc<RwLock<BucketMetadataSys>>>
pub fn bucket_metadata_sys(&self) -> Option<Arc<RwLock<BucketMetadataSys>>>
Get the bucket metadata system
Sourcepub fn endpoints(&self) -> EndpointServerPools
pub fn endpoints(&self) -> EndpointServerPools
Get the global endpoints
Sourcepub fn instance_endpoints(&self) -> Option<EndpointServerPools>
pub fn instance_endpoints(&self) -> Option<EndpointServerPools>
Get this store instance’s endpoint topology without consulting process globals.
Sourcepub fn tier_config_mgr(&self) -> Arc<RwLock<TierConfigMgr>> ⓘ
pub fn tier_config_mgr(&self) -> Arc<RwLock<TierConfigMgr>> ⓘ
Get the tier config manager
Sourcepub fn server_config(&self) -> Option<Config>
pub fn server_config(&self) -> Option<Config>
Get the server configuration
Sourcepub fn storage_class(&self) -> Option<Config>
pub fn storage_class(&self) -> Option<Config>
Get the storage class configuration
Source§impl ECStore
Phase 4: Server address accessors
These provide a unified API through ECStore for accessing server-level
configuration globals. The globals remain the source of truth.
impl ECStore
Phase 4: Server address accessors These provide a unified API through ECStore for accessing server-level configuration globals. The globals remain the source of truth.
Source§impl ECStore
Phase 5: Per-instance erasure setup accessors (backlog#939)
impl ECStore
Phase 5: Per-instance erasure setup accessors (backlog#939)
These read this instance’s own InstanceContext rather than a process
global, so two instances carrying different contexts stay isolated. The
legacy free-function facade (runtime::global::is_erasure etc.) forwards to
the current instance’s context, preserving single-instance behavior.
Sourcepub async fn setup_is_erasure(&self) -> bool
pub async fn setup_is_erasure(&self) -> bool
Whether this instance uses erasure coding (single-node or distributed).
Sourcepub async fn setup_is_dist_erasure(&self) -> bool
pub async fn setup_is_dist_erasure(&self) -> bool
Whether this instance uses distributed erasure coding.
Sourcepub async fn setup_is_erasure_sd(&self) -> bool
pub async fn setup_is_erasure_sd(&self) -> bool
Whether this instance uses single-drive erasure coding.
pub fn scanner_namespace_mutation_generation(&self) -> u64
pub async fn scanner_data_movement_active(&self) -> bool
Sourcepub async fn scanner_data_movement_activity(&self) -> (bool, bool, u64)
pub async fn scanner_data_movement_activity(&self) -> (bool, bool, u64)
Return the storage-owned movement state and generation as one authenticated activity snapshot. The read lock is acquired before the state locks (cancelers, pool metadata, then rebalance metadata), matching the transition writer order and preventing a terminal state from being reported with the preceding generation.
pub fn scanner_data_movement_generation(&self) -> u64
pub fn scanner_data_movement_generation_exhausted(&self) -> bool
pub fn scanner_data_movement_changed(&self) -> Arc<Notify> ⓘ
Sourcepub async fn scanner_data_usage_publication_blocked(&self) -> bool
pub async fn scanner_data_usage_publication_blocked(&self) -> bool
Returns whether scanner metadata may still be hidden by a local data-movement state. Terminal failed/canceled decommission entries remain suspended until an operator clears or retries them, so they are a publication barrier even after the worker has stopped. Active PUT rename fanouts also defer publication, including post-ACK tails.
pub async fn scanner_data_movement_pause_status( &self, ) -> ScannerDataMovementPauseStatus
Sourcepub async fn scanner_data_usage_publication_read_guard(
&self,
) -> (OwnedRwLockReadGuard<()>, u64)
pub async fn scanner_data_usage_publication_read_guard( &self, ) -> (OwnedRwLockReadGuard<()>, u64)
Admit one short data-usage publication commit under the same per-instance gate used by decommission side effects and transitions. The epoch is sampled while the read guard is held, so a transition cannot cross this admission without waiting for the commit to finish.
Sourcepub async fn scanner_data_usage_publication_admission_guard(
&self,
) -> Option<(OwnedRwLockReadGuard<()>, u64)>
pub async fn scanner_data_usage_publication_admission_guard( &self, ) -> Option<(OwnedRwLockReadGuard<()>, u64)>
Acquire the movement gate and inspect the movement owner once. The state inspection is performed after acquiring the read guard so a transition cannot update its durable state between the check and the publication commit.
Sourcepub async fn scanner_data_usage_publication_commit_scope(
&self,
expected_movement_epoch: u64,
safe_deadline: Instant,
remote_lease_tokens: Vec<Uuid>,
) -> Option<ScannerPublicationCommitScope>
pub async fn scanner_data_usage_publication_commit_scope( &self, expected_movement_epoch: u64, safe_deadline: Instant, remote_lease_tokens: Vec<Uuid>, ) -> Option<ScannerPublicationCommitScope>
Acquire a storage-owned scanner publication scope. Unlike the legacy admission helper, the movement permit is owned by the returned scope and therefore survives cancellation of the scanner coordinator while the actual metadata mutation drains.
pub async fn scanner_data_usage_publication_commit_scope_with_release_flag( &self, expected_movement_epoch: u64, safe_deadline: Instant, remote_lease_tokens: Vec<Uuid>, lease_release_safe: Arc<Atomic<bool>>, ) -> Option<ScannerPublicationCommitScope>
Sourcepub async fn acquire_scanner_publication_lease(
&self,
expected_generation: u64,
ttl: Duration,
) -> Result<(Uuid, u64), StorageError>
pub async fn acquire_scanner_publication_lease( &self, expected_generation: u64, ttl: Duration, ) -> Result<(Uuid, u64), StorageError>
Acquire a storage-owned read admission for a coordinator’s final scanner publication. The guard remains in the context’s lease table, so a local movement writer cannot pass the peer while its authoritative PUT is in flight.
pub async fn release_scanner_publication_lease(&self, token: Uuid) -> bool
Sourcepub async fn validate_scanner_publication_lease(
&self,
token: Uuid,
expected_generation: u64,
) -> Result<(), StorageError>
pub async fn validate_scanner_publication_lease( &self, token: Uuid, expected_generation: u64, ) -> Result<(), StorageError>
Revalidate a previously acquired remote publication lease immediately before the coordinator’s final metadata write. The operation read guard makes the movement snapshot and token lookup one storage-owned admission; a restarted context has no old token and therefore fails closed even if its generation counter has returned to zero.
Sourcepub async fn acquire_scanner_publication_lease_guard(
&self,
token: Uuid,
) -> Result<OwnedRwLockReadGuard<()>, StorageError>
pub async fn acquire_scanner_publication_lease_guard( &self, token: Uuid, ) -> Result<OwnedRwLockReadGuard<()>, StorageError>
Acquire the target-side read guard bound to a previously granted lease. The guard is returned to the RPC handler and must remain alive through the complete rename/write operation. A lease token is process-owned; restart, expiry, generation changes, or blocked movement all reject it before the target disk is touched.
Source§impl ECStore
impl ECStore
Sourcepub async fn put_object_with_old_current_size(
&self,
bucket: &str,
object: &str,
data: &mut PutObjReader,
opts: &ObjectOptions,
) -> Result<(ObjectInfo, Option<OldCurrentSize>), StorageError>
pub async fn put_object_with_old_current_size( &self, bucket: &str, object: &str, data: &mut PutObjReader, opts: &ObjectOptions, ) -> Result<(ObjectInfo, Option<OldCurrentSize>), StorageError>
put_object plus the rename_data old-size backfill
(rustfs/backlog#1009); see SetDisks::put_object_with_old_current_size.
Post-write hooks (immediate ILM transition enqueue, list-cache
invalidation) match the plain put_object path exactly.
Trait Implementations§
Source§impl BucketOperations for ECStore
impl BucketOperations for ECStore
type Error = StorageError
fn make_bucket<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
opts: &'life2 MakeBucketOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
fn get_bucket_info<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
opts: &'life2 BucketOptions,
) -> Pin<Box<dyn Future<Output = Result<BucketInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
fn list_bucket<'life0, 'life1, 'async_trait>(
&'life0 self,
opts: &'life1 BucketOptions,
) -> Pin<Box<dyn Future<Output = Result<Vec<BucketInfo>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
fn delete_bucket<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
opts: &'life2 DeleteBucketOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
Source§impl HealOperations for ECStore
impl HealOperations for ECStore
type Error = StorageError
type HealResultItem = HealResultItem
type HealOptions = HealOpts
fn heal_format<'life0, 'async_trait>(
&'life0 self,
dry_run: bool,
) -> Pin<Box<dyn Future<Output = Result<(HealResultItem, Option<StorageError>), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
ECStore: 'async_trait,
fn heal_bucket<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
opts: &'life2 HealOpts,
) -> Pin<Box<dyn Future<Output = Result<HealResultItem, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
fn heal_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
version_id: &'life3 str,
opts: &'life4 HealOpts,
) -> Pin<Box<dyn Future<Output = Result<(HealResultItem, Option<StorageError>), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
ECStore: 'async_trait,
fn get_pool_and_set<'life0, 'life1, 'async_trait>(
&'life0 self,
id: &'life1 str,
) -> Pin<Box<dyn Future<Output = Result<(Option<usize>, Option<usize>, Option<usize>), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
fn check_abandoned_parts<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 HealOpts,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
Source§impl ListOperations for ECStore
impl ListOperations for ECStore
type Error = StorageError
type ListObjectsV2Info = ListObjectsV2Info<ObjectInfo>
type ListObjectVersionsInfo = ListObjectVersionsInfo<ObjectInfo>
type ObjectInfoOrErr = ObjectInfoOrErr<ObjectInfo, StorageError>
type WalkOptions = WalkOptions<fn(&FileInfo) -> bool>
type WalkCancellation = CancellationToken
type WalkResultSender = Sender<ObjectInfoOrErr<ObjectInfo, StorageError>>
fn list_objects_v2<'life0, 'life1, 'async_trait>(
self: Arc<ECStore>,
bucket: &'life0 str,
prefix: &'life1 str,
continuation_token: Option<String>,
delimiter: Option<String>,
max_keys: i32,
fetch_owner: bool,
start_after: Option<String>,
incl_deleted: bool,
) -> Pin<Box<dyn Future<Output = Result<ListObjectsV2Info<ObjectInfo>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
fn list_object_versions<'life0, 'life1, 'async_trait>(
self: Arc<ECStore>,
bucket: &'life0 str,
prefix: &'life1 str,
marker: Option<String>,
version_marker: Option<String>,
delimiter: Option<String>,
max_keys: i32,
) -> Pin<Box<dyn Future<Output = Result<ListObjectVersionsInfo<ObjectInfo>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
fn walk<'life0, 'life1, 'async_trait>(
self: Arc<ECStore>,
rx: CancellationToken,
bucket: &'life0 str,
prefix: &'life1 str,
result: Sender<ObjectInfoOrErr<ObjectInfo, StorageError>>,
opts: WalkOptions<fn(&FileInfo) -> bool>,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
Source§impl MultipartOperations for ECStore
impl MultipartOperations for ECStore
type Error = StorageError
type ObjectInfo = ObjectInfo
type ObjectOptions = ObjectOptions
type PutObjectReader = PutObjReader
type CompletePart = CompletePart
type ListMultipartsInfo = ListMultipartsInfo
type MultipartUploadResult = MultipartUploadResult
type PartInfo = PartInfo
type MultipartInfo = MultipartInfo
type ListPartsInfo = ListPartsInfo
fn list_multipart_uploads<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
prefix: &'life2 str,
key_marker: Option<String>,
upload_id_marker: Option<String>,
delimiter: Option<String>,
max_uploads: usize,
) -> Pin<Box<dyn Future<Output = Result<ListMultipartsInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
fn new_multipart_upload<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<MultipartUploadResult, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn copy_object_part<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'life8, 'async_trait>(
&'life0 self,
src_bucket: &'life1 str,
src_object: &'life2 str,
_dst_bucket: &'life3 str,
_dst_object: &'life4 str,
_upload_id: &'life5 str,
_part_id: usize,
_start_offset: i64,
_length: i64,
_src_info: &'life6 ObjectInfo,
_src_opts: &'life7 ObjectOptions,
_dst_opts: &'life8 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
'life5: 'async_trait,
'life6: 'async_trait,
'life7: 'async_trait,
'life8: 'async_trait,
ECStore: 'async_trait,
fn put_object_part<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
upload_id: &'life3 str,
part_id: usize,
data: &'life4 mut PutObjReader,
opts: &'life5 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<PartInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
'life5: 'async_trait,
ECStore: 'async_trait,
fn get_multipart_info<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
upload_id: &'life3 str,
opts: &'life4 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<MultipartInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
ECStore: 'async_trait,
fn list_object_parts<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
upload_id: &'life3 str,
part_number_marker: Option<usize>,
max_parts: usize,
opts: &'life4 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ListPartsInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
ECStore: 'async_trait,
fn abort_multipart_upload<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
upload_id: &'life3 str,
opts: &'life4 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
ECStore: 'async_trait,
fn complete_multipart_upload<'life0, 'life1, 'life2, 'life3, 'async_trait>(
self: Arc<ECStore>,
bucket: &'life0 str,
object: &'life1 str,
upload_id: &'life2 str,
uploaded_parts: Vec<CompletePart>,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
Source§impl NamespaceLocking for ECStore
impl NamespaceLocking for ECStore
type Error = StorageError
type NamespaceLock = NamespaceLockWrapper
fn new_ns_lock<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
) -> Pin<Box<dyn Future<Output = Result<NamespaceLockWrapper, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
Source§impl ObjectIO for ECStore
impl ObjectIO for ECStore
type Error = StorageError
type RangeSpec = HTTPRangeSpec
type HeaderMap = HeaderMap
type ObjectOptions = ObjectOptions
type ObjectInfo = ObjectInfo
type GetObjectReader = GetObjectReader
type PutObjectReader = PutObjReader
fn get_object_reader<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
range: Option<HTTPRangeSpec>,
h: HeaderMap,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<GetObjectReader, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn put_object<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
data: &'life3 mut PutObjReader,
opts: &'life4 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
ECStore: 'async_trait,
Source§impl ObjectOperations for ECStore
impl ObjectOperations for ECStore
type Error = StorageError
type ObjectInfo = ObjectInfo
type ObjectOptions = ObjectOptions
type FileInfo = FileInfo
type ObjectToDelete = ObjectToDelete
type DeletedObject = DeletedObject
fn get_object_info<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn verify_object_integrity<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn copy_object<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'life6, 'life7, 'async_trait>(
&'life0 self,
src_bucket: &'life1 str,
src_object: &'life2 str,
dst_bucket: &'life3 str,
dst_object: &'life4 str,
src_info: &'life5 mut ObjectInfo,
src_opts: &'life6 ObjectOptions,
dst_opts: &'life7 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
'life4: 'async_trait,
'life5: 'async_trait,
'life6: 'async_trait,
'life7: 'async_trait,
ECStore: 'async_trait,
fn delete_object_version<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
fi: &'life3 FileInfo,
force_del_marker: bool,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn delete_object<'life0, 'life1, 'life2, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
fn delete_objects<'life0, 'life1, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
objects: Vec<ObjectToDelete>,
opts: ObjectOptions,
) -> Pin<Box<dyn Future<Output = (Vec<DeletedObject>, Vec<Option<StorageError>>)> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
ECStore: 'async_trait,
fn put_object_metadata<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<ObjectInfo, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn add_partial<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
version_id: &'life3 str,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn transition_object<'life0, 'life1, 'life2, 'life3, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
object: &'life2 str,
opts: &'life3 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
'life3: 'async_trait,
ECStore: 'async_trait,
fn restore_transitioned_object<'life0, 'life1, 'life2, 'async_trait>(
self: Arc<ECStore>,
bucket: &'life0 str,
object: &'life1 str,
opts: &'life2 ObjectOptions,
) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
'life2: 'async_trait,
ECStore: 'async_trait,
Source§fn delete_objects_with_accounting<'life0, 'life1, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
objects: Vec<Self::ObjectToDelete>,
opts: Self::ObjectOptions,
) -> Pin<Box<dyn Future<Output = (Vec<Self::DeletedObject>, Vec<Option<Self::Error>>, Vec<Option<DeleteAccounting>>)> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
fn delete_objects_with_accounting<'life0, 'life1, 'async_trait>(
&'life0 self,
bucket: &'life1 str,
objects: Vec<Self::ObjectToDelete>,
opts: Self::ObjectOptions,
) -> Pin<Box<dyn Future<Output = (Vec<Self::DeletedObject>, Vec<Option<Self::Error>>, Vec<Option<DeleteAccounting>>)> + Send + 'async_trait>>where
'life0: 'async_trait,
'life1: 'async_trait,
Self: 'async_trait,
Source§impl StorageAdminApi for ECStore
impl StorageAdminApi for ECStore
type BackendInfo = BackendInfo
type StorageInfo = StorageInfo
type Disk = Arc<Disk>
type Error = StorageError
fn backend_info<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = <ECStore as StorageAdminApi>::BackendInfo> + Send + 'async_trait>>where
'life0: 'async_trait,
ECStore: 'async_trait,
fn storage_info<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = <ECStore as StorageAdminApi>::StorageInfo> + Send + 'async_trait>>where
'life0: 'async_trait,
ECStore: 'async_trait,
fn local_storage_info<'life0, 'async_trait>(
&'life0 self,
) -> Pin<Box<dyn Future<Output = <ECStore as StorageAdminApi>::StorageInfo> + Send + 'async_trait>>where
'life0: 'async_trait,
ECStore: 'async_trait,
fn disk_set_inventory<'life0, 'async_trait>(
&'life0 self,
selector: DiskSetSelector,
) -> Pin<Box<dyn Future<Output = Result<Vec<Option<<ECStore as StorageAdminApi>::Disk>>, StorageError>> + Send + 'async_trait>>where
'life0: 'async_trait,
ECStore: 'async_trait,
fn set_drive_counts(&self) -> Vec<usize>
Auto Trait Implementations§
impl !Freeze for ECStore
impl !RefUnwindSafe for ECStore
impl !UnwindSafe for ECStore
impl Send for ECStore
impl Sync for ECStore
impl Unpin for ECStore
impl UnsafeUnpin for ECStore
Blanket Implementations§
Source§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
Source§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
Source§impl<T> FutureExt for T
impl<T> FutureExt for T
Source§fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ
Source§fn with_current_context(self) -> WithContext<Self> ⓘ
fn with_current_context(self) -> WithContext<Self> ⓘ
Source§impl<T> Instrument for T
impl<T> Instrument for T
Source§fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
fn instrument(self, span: Span) -> Instrumented<Self> ⓘ
Source§fn in_current_span(self) -> Instrumented<Self> ⓘ
fn in_current_span(self) -> Instrumented<Self> ⓘ
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§impl<T> IntoRequest<T> for T
impl<T> IntoRequest<T> for T
Source§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
T in a tonic::Request