Struct ObjectLockPresenceFilter 

pub struct ObjectLockPresenceFilter<Src: BlockMetadata> { /* private fields */ }

G2→G4 filter with distributed locking: check meta, acquire lock, track acquired locks.

This filter implements the full locking protocol for object storage offloads:

1. Check if .meta file exists (block already offloaded) - skip if yes
2. Check if currently pending (in-flight transfer) - skip if yes
3. Try to acquire .lock file with conditional PUT
   • If lock doesn’t exist, create it atomically
   • If lock exists and expired, overwrite it
   • If lock exists and valid (owned by another instance), skip
4. If we own the lock (either just acquired or already owned), pass the block

Lock Management

Locks acquired during policy evaluation are tracked and must be:

• Released after successful transfer (via ObjectTransferExecutor)
• Released on error/cancellation (via guard or explicit cleanup)

Duplicate Prevention

When a PendingTracker is configured, blocks currently in-flight are filtered out before checking object storage, avoiding redundant network calls.

Example

let lock_manager = Arc::new(S3LockManager::new(s3_client, instance_id));
let tracker = Arc::new(PendingTracker::new());
let filter = ObjectLockPresenceFilter::<G2>::new(lock_manager)
    .with_pending_tracker(tracker);
// Blocks already offloaded, in-flight, or locked by others will be filtered out

Implementations

impl<Src: BlockMetadata> ObjectLockPresenceFilter<Src>

pub fn new(lock_manager: Arc<dyn ObjectLockManager>) -> Self

Create a new object lock presence filter.

pub fn with_pending_tracker(self, tracker: Arc<PendingTracker>) -> Self

Add a pending tracker for duplicate prevention.

When set, blocks that are currently in-flight (passed policy but not yet stored in object storage) will be filtered out.

pub fn pending_tracker(&self) -> Option<&Arc<PendingTracker>>

Get a reference to the pending tracker if configured.

pub fn lock_manager(&self) -> &Arc<dyn ObjectLockManager>

Get a reference to the lock manager.

Trait Implementations

impl<Src: BlockMetadata> OffloadPolicy<Src> for ObjectLockPresenceFilter<Src>

fn name(&self) -> &str

Unique name for this policy (for logging/debugging).

fn evaluate<'a>(&'a self, ctx: &'a EvalContext<Src>) -> PolicyFuture<'a>

Evaluate whether a block should be offloaded.

fn evaluate_batch<'a>( &'a self, contexts: &'a [EvalContext<Src>], ) -> PolicyBatchFuture<'a>

Batch evaluate multiple blocks.