Skip to main content

NotifyStore

Struct NotifyStore 

Source
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

Source§

impl ECStore

Source

pub async fn load_heal_lifecycle_expiry_context( &self, bucket: &str, ) -> Result<Option<HealLifecycleExpiryContext>, StorageError>

Source

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>

Source

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.

Source

pub async fn pool_meta_write_gate_status(&self) -> PoolMetaWriteGateStatus

A health probe must not wait behind a metadata transaction’s disk I/O.

Source

pub async fn pool_meta_write_status(&self) -> Result<(), StorageError>

A health probe must not wait behind a metadata transaction’s disk I/O.

Source

pub async fn status(&self, idx: usize) -> Result<PoolStatus, StorageError>

Source

pub async fn refresh_pool_status_meta(&self) -> Result<(), StorageError>

Source

pub async fn decommission_cancel( self: &Arc<ECStore>, idx: usize, ) -> Result<(), StorageError>

Source

pub async fn clear_decommission( self: &Arc<ECStore>, idx: usize, ) -> Result<(), StorageError>

Source

pub async fn is_decommission_running(&self) -> bool

Source

pub async fn spawn_missing_local_decommission_routines( self: &Arc<ECStore>, ) -> Result<(), StorageError>

Source

pub async fn decommission( &self, rx: CancellationToken, indices: Vec<usize>, ) -> Result<(), StorageError>

Source

pub async fn do_decommission_in_routine( self: &Arc<ECStore>, canceler: DecommissionCanceler, idx: usize, entry_budget: Arc<Semaphore>, ) -> Result<(), StorageError>

Source

pub async fn decommission_failed(&self, idx: usize) -> Result<(), StorageError>

Source

pub async fn complete_decommission( &self, idx: usize, ) -> Result<(), StorageError>

Source

pub async fn start_decommission( &self, indices: Vec<usize>, ) -> Result<(), StorageError>

Source§

impl ECStore

Source

pub async fn load_rebalance_meta(&self) -> Result<(), StorageError>

Source

pub async fn prepare_rebalance_stop( &self, ) -> Result<Option<String>, StorageError>

Cancels local admission before refreshing the persisted stop target under the start gate.

Source

pub async fn refresh_rebalance_status_meta(&self) -> Result<(), StorageError>

Source

pub async fn update_rebalance_stats(&self) -> Result<(), StorageError>

Source

pub async fn init_rebalance_meta( &self, bucktes: Vec<String>, ) -> Result<String, StorageError>

Source

pub async fn init_and_start_rebalance( self: &Arc<ECStore>, bucktes: Vec<String>, ) -> Result<String, StorageError>

Source

pub async fn init_rebalance_start( self: &Arc<ECStore>, bucktes: Vec<String>, ) -> Result<String, StorageError>

Source

pub async fn start_rebalance_for_id( self: &Arc<ECStore>, expected_id: &str, ) -> Result<(), StorageError>

Source

pub async fn rollback_rebalance_start_for_id( self: &Arc<ECStore>, expected_id: Option<&str>, start_error: String, ) -> Result<(), StorageError>

Source

pub async fn update_pool_stats( &self, pool_index: usize, bucket: String, fi: &FileInfo, ) -> Result<(), StorageError>

Source

pub async fn update_pool_stats_batch( &self, pool_index: usize, bucket: String, versions: &[&FileInfo], ) -> Result<(), StorageError>

Source

pub async fn next_rebal_bucket( &self, pool_index: usize, expected_id: &str, ) -> Result<Option<String>, StorageError>

Source

pub async fn bucket_rebalance_done( &self, pool_index: usize, bucket: String, expected_id: &str, ) -> Result<(), StorageError>

Source

pub async fn is_rebalance_started(&self) -> bool

Source

pub async fn is_rebalance_conflicting_with_decommission(&self) -> bool

Source

pub async fn is_pool_rebalancing(&self, pool_index: usize) -> bool

Source

pub async fn pool_rebalance_status( &self, pool_index: usize, ) -> (RebalStatus, bool)

Source

pub async fn current_rebalance_id(&self) -> Option<String>

Source

pub async fn cancel_rebalance_admission_for_id( &self, expected_id: &str, ) -> Result<(), StorageError>

Source

pub async fn stop_rebalance(self: &Arc<ECStore>) -> Result<(), StorageError>

Source

pub async fn stop_rebalance_for_id( self: &Arc<ECStore>, expected_id: Option<&str>, ) -> Result<(), StorageError>

Source

pub async fn record_rebalance_stop_propagation( self: &Arc<ECStore>, expected_id: &str, record: RebalanceStopPropagationRecord, ) -> Result<(), StorageError>

Source§

impl ECStore

Source§

impl ECStore

Source

pub async fn save_rebalance_stats( &self, pool_idx: usize, opt: RebalSaveOpt, ) -> Result<(), StorageError>

Source

pub async fn save_rebalance_stats_for_id( &self, pool_idx: usize, opt: RebalSaveOpt, expected_id: &str, ) -> Result<(), StorageError>

Source§

impl ECStore

Source

pub async fn get_bucket_metadata( &self, bucket: &str, ) -> Result<Arc<BucketMetadata>, StorageError>

Source

pub async fn get_bucket_policy( &self, bucket: &str, ) -> Result<(BucketPolicy, OffsetDateTime), StorageError>

Source

pub async fn get_bucket_policy_raw( &self, bucket: &str, ) -> Result<(String, OffsetDateTime), StorageError>

Source

pub async fn restricts_public_bucket_access( &self, bucket: &str, ) -> Result<bool, StorageError>

Source

pub async fn update_bucket_metadata_config( &self, bucket: &str, config_file: &str, data: Vec<u8>, ) -> Result<OffsetDateTime, StorageError>

Source

pub async fn bucket_incarnation_id( &self, bucket: &str, ) -> Result<Uuid, StorageError>

Source

pub async fn bucket_incarnation_id_from_disk( &self, bucket: &str, ) -> Result<Uuid, StorageError>

Source

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.

Source

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.

Source

pub async fn list_bucket_for_scanner( &self, opts: &BucketOptions, ) -> Result<ScannerBucketListing, StorageError>

Source§

impl ECStore

Source

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>

Source

pub async fn heal_bucket_at_incarnation( self: &Arc<ECStore>, bucket: &str, expected: Uuid, opts: &HealOpts, ) -> Result<HealResultItem, StorageError>

Source

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>

Source

pub async fn heal_object_at_incarnation( self: &Arc<ECStore>, bucket: &str, object: &str, version_id: &str, expected: Uuid, opts: &HealOpts, ) -> Result<HealObjectStorageResult, StorageError>

Source

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.

Source

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.

Source

pub async fn heal_replacement_format( &self, dry_run: bool, pool_index: usize, set_index: usize, targets: &[String], ) -> Result<(HealResultItem, Option<StorageError>), StorageError>

Source

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>

Source

pub async fn heal_object_with_proof( &self, bucket: &str, object: &str, version_id: &str, opts: &HealOpts, ) -> Result<HealObjectStorageResult, StorageError>

Source§

impl ECStore

Source

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

Source

pub fn background_cancel_token(&self) -> Option<CancellationToken>

Shutdown token owned by this store instance.

Source

pub fn validate_startup_storage_class( endpoint_pools: &EndpointServerPools, ) -> Result<(), StorageError>

Validate topology and process storage-class overrides before any disk is opened.

Source

pub async fn new( address: SocketAddr, endpoint_pools: EndpointServerPools, ctx: CancellationToken, ) -> Result<Arc<ECStore>, StorageError>

Source

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.

Source

pub async fn init( self: &Arc<ECStore>, rx: CancellationToken, ) -> Result<(), StorageError>

Source

pub fn init_local_disks()

Source

pub fn single_pool(&self) -> bool

Source

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

Source

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>

Source

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>

Source

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>

Source

pub async fn list_path( self: Arc<ECStore>, o: &ListPathOptions, ) -> Result<MetaCacheEntriesSortedResult, StorageError>

Source

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

Source

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

Source

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.

Source

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.

Source

pub async fn prepare_get_object_reader( &self, bucket: &str, object: &str, range: Option<HTTPRangeSpec>, headers: HeaderMap, opts: &ObjectOptions, ) -> Result<PreparedGetObjectReader, StorageError>

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

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.

Source

pub async fn delete_object_with_tier_delete_journal( self: &Arc<ECStore>, bucket: &str, object: &str, opts: ObjectOptions, ) -> Result<ObjectInfo, StorageError>

Source

pub async fn delete_objects_with_tier_delete_journal( self: &Arc<ECStore>, bucket: &str, objects: Vec<ObjectToDelete>, opts: ObjectOptions, ) -> (Vec<DeletedObject>, Vec<Option<StorageError>>)

Source

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

Source

pub async fn write_local_metadata_at_incarnation( self: &Arc<ECStore>, disk_ref: &str, target: (&str, &str), fi: FileInfo, expected: Uuid, ) -> Result<(), DiskError>

Source

pub async fn delete_local_path_at_incarnation( self: &Arc<ECStore>, disk_ref: &str, target: (&str, &str), opts: DeleteOptions, expected: Uuid, ) -> Result<(), DiskError>

Source

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>

Source

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.

Source

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.

Source

pub async fn undo_local_write( &self, disk_ref: &str, volume: &str, path: &str, fi: FileInfo, opts: DeleteOptions, ) -> Result<(), DiskError>

Source§

impl ECStore

Source

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.

Source

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).

Source

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.

Source

pub fn get_server_config(&self) -> Option<Config>

Get server configuration (delegates to global)

Source

pub fn set_server_config(&self, cfg: Config)

Set server configuration (delegates to global)

Source

pub fn get_storage_class(&self) -> Option<Config>

Get storage class configuration (delegates to global)

Source

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.

Source

pub fn notification_system(&self) -> Option<Arc<NotificationSys>>

Get the notification system

Source

pub fn bucket_metadata_sys(&self) -> Option<Arc<RwLock<BucketMetadataSys>>>

Get the bucket metadata system

Source

pub fn endpoints(&self) -> EndpointServerPools

Get the global endpoints

Source

pub fn instance_endpoints(&self) -> Option<EndpointServerPools>

Get this store instance’s endpoint topology without consulting process globals.

Source

pub fn region(&self) -> Option<Region>

Get the global region

Source

pub fn tier_config_mgr(&self) -> Arc<RwLock<TierConfigMgr>> ⓘ

Get the tier config manager

Source

pub fn server_config(&self) -> Option<Config>

Get the server configuration

Source

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.

Source

pub fn port(&self) -> u16

Get the server port

Source

pub async fn host(&self) -> String

Get the server host

Source

pub async fn addr(&self) -> String

Get the server address (host:port)

Source§

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.

Source

pub async fn setup_is_erasure(&self) -> bool

Whether this instance uses erasure coding (single-node or distributed).

Source

pub async fn setup_is_dist_erasure(&self) -> bool

Whether this instance uses distributed erasure coding.

Source

pub async fn setup_is_erasure_sd(&self) -> bool

Whether this instance uses single-drive erasure coding.

Source

pub fn scanner_namespace_mutation_generation(&self) -> u64

Source

pub async fn scanner_data_movement_active(&self) -> bool

Source

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.

Source

pub fn scanner_data_movement_generation(&self) -> u64

Source

pub fn scanner_data_movement_generation_exhausted(&self) -> bool

Source

pub fn scanner_data_movement_changed(&self) -> Arc<Notify> ⓘ

Source

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.

Source

pub async fn scanner_data_movement_pause_status( &self, ) -> ScannerDataMovementPauseStatus

Source

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.

Source

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.

Source

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.

Source

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>

Source

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.

Source

pub async fn release_scanner_publication_lease(&self, token: Uuid) -> bool

Source

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.

Source

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

Source

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

Source§

type Error = StorageError

Source§

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,

Source§

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,

Source§

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,

Source§

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 Debug for ECStore

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more
Source§

impl HealOperations for ECStore

Source§

type Error = StorageError

Source§

type HealResultItem = HealResultItem

Source§

type HealOptions = HealOpts

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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

Source§

type Error = StorageError

Source§

type ListObjectsV2Info = ListObjectsV2Info<ObjectInfo>

Source§

type ListObjectVersionsInfo = ListObjectVersionsInfo<ObjectInfo>

Source§

type ObjectInfoOrErr = ObjectInfoOrErr<ObjectInfo, StorageError>

Source§

type WalkOptions = WalkOptions<fn(&FileInfo) -> bool>

Source§

type WalkCancellation = CancellationToken

Source§

type WalkResultSender = Sender<ObjectInfoOrErr<ObjectInfo, StorageError>>

Source§

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,

Source§

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,

Source§

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

Source§

type Error = StorageError

Source§

type ObjectInfo = ObjectInfo

Source§

type ObjectOptions = ObjectOptions

Source§

type PutObjectReader = PutObjReader

Source§

type CompletePart = CompletePart

Source§

type ListMultipartsInfo = ListMultipartsInfo

Source§

type MultipartUploadResult = MultipartUploadResult

Source§

type PartInfo = PartInfo

Source§

type MultipartInfo = MultipartInfo

Source§

type ListPartsInfo = ListPartsInfo

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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

Source§

type Error = StorageError

Source§

type NamespaceLock = NamespaceLockWrapper

Source§

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

Source§

type Error = StorageError

Source§

type RangeSpec = HTTPRangeSpec

Source§

type HeaderMap = HeaderMap

Source§

type ObjectOptions = ObjectOptions

Source§

type ObjectInfo = ObjectInfo

Source§

type GetObjectReader = GetObjectReader

Source§

type PutObjectReader = PutObjReader

Source§

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,

Source§

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

Source§

type Error = StorageError

Source§

type ObjectInfo = ObjectInfo

Source§

type ObjectOptions = ObjectOptions

Source§

type FileInfo = FileInfo

Source§

type ObjectToDelete = ObjectToDelete

Source§

type DeletedObject = DeletedObject

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

fn get_object_tags<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, bucket: &'life1 str, object: &'life2 str, opts: &'life3 ObjectOptions, ) -> Pin<Box<dyn Future<Output = Result<String, StorageError>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, ECStore: 'async_trait,

Source§

fn put_object_tags<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, bucket: &'life1 str, object: &'life2 str, tags: &'life3 str, 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§

fn delete_object_tags<'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,

Source§

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,

Source§

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,

Source§

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,

Delete objects and optionally return commit-time accounting identities. The default preserves the ordinary delete contract for implementations that do not expose storage-level accounting details.
Source§

impl StorageAdminApi for ECStore

Source§

type BackendInfo = BackendInfo

Source§

type StorageInfo = StorageInfo

Source§

type Disk = Arc<Disk>

Source§

type Error = StorageError

Source§

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,

Source§

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,

Source§

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,

Source§

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,

Source§

fn set_drive_counts(&self) -> Vec<usize>

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

Source§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

Source§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

Source§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

Source§

impl<T> CompatExt for T

Source§

fn compat(self) -> Compat<T> ⓘ
where T: Sized,

Applies the Compat adapter by value. Read more
Source§

fn compat_ref(&self) -> Compat<&T> ⓘ

Applies the Compat adapter by shared reference. Read more
Source§

fn compat_mut(&mut self) -> Compat<&mut T> ⓘ

Applies the Compat adapter by mutable reference. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> FromExt for T

Source§

fn from_<T>(t: T) -> Self
where Self: From<T>,

Source§

impl<T> FutureExt for T

Source§

fn with_context(self, otel_cx: Context) -> WithContext<Self> ⓘ

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
Source§

fn with_current_context(self) -> WithContext<Self> ⓘ

Attaches the current Context to this type, returning a WithContext wrapper. Read more
Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self> ⓘ

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self> ⓘ

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts 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 more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts 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 more
Source§

impl<T> IntoExt for T

Source§

fn into_<T>(self) -> T
where Self: Into<T>,

Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
Source§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

Source§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
Source§

impl<L> LayerExt<L> for L

Source§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in Layered.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> PolicyExt for T
where T: ?Sized,

Source§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow only if self and other return Action::Follow. Read more
Source§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns Action::Follow if either self or other returns Action::Follow. Read more
Source§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> ReplicationObjectIO for T
where T: ObjectIO<Error = StorageError, RangeSpec = HTTPRangeSpec, HeaderMap = HeaderMap, ObjectOptions = ObjectOptions, ObjectInfo = ObjectInfo, GetObjectReader = GetObjectReader, PutObjectReader = PutObjReader> + Send + Sync + Debug + 'static,

Source§

impl<T> ReplicationStorage for T
where T: ObjectOperations<Error = StorageError, ObjectInfo = ObjectInfo, ObjectOptions = ObjectOptions, FileInfo = FileInfo, ObjectToDelete = ObjectToDelete, DeletedObject = DeletedObject> + NamespaceLocking<Error = StorageError, NamespaceLock = NamespaceLockWrapper> + ListOperations<Error = StorageError, ListObjectsV2Info = ListObjectsV2Info<ObjectInfo>, ListObjectVersionsInfo = ListObjectVersionsInfo<ObjectInfo>, ObjectInfoOrErr = ObjectInfoOrErr<ObjectInfo, StorageError>, WalkOptions = WalkOptions<fn(&FileInfo) -> bool>, WalkCancellation = CancellationToken, WalkResultSender = Sender<ObjectInfoOrErr<ObjectInfo, StorageError>>> + ObjectIO<Error = StorageError, RangeSpec = HTTPRangeSpec, HeaderMap = HeaderMap, ObjectOptions = ObjectOptions, ObjectInfo = ObjectInfo, GetObjectReader = GetObjectReader, PutObjectReader = PutObjReader>,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T> TryFromExt for T

Source§

fn try_from_<T>(t: T) -> Result<Self, Self::Error>
where Self: TryFrom<T>,

Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> TryIntoExt for T

Source§

fn try_into_<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> ⓘ
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self> ⓘ

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more