The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
refactor(storage): update fenced backend implementation
Steven Enamakelb05f38126fe8
diff --git a/crates/openhuman-core/src/profiles/host_backend.rs b/crates/openhuman-core/src/profiles/host_backend.rsindex 30d54d8bac..0b5f104576 100644--- a/crates/openhuman-core/src/profiles/host_backend.rs+++ b/crates/openhuman-core/src/profiles/host_backend.rs@@ -4,16 +4,35 @@use std::collections::HashMap;use std::sync::{Arc, Mutex};-use super::host::{ProfileHost, Slot};+use super::host::{Profile, ProfileHost, Slot};use super::lease as profile_lease;use super::lifecycle::ProfileLocks;use super::registry::ProfileRegistry;use crate::core::runtime::{CoreContext, SaasConfig};use crate::storage::fence::FenceRegistry;use crate::storage::fenced_backend::FencedBackend;-use crate::storage::StorageBackend;+use crate::storage::{StorageBackend, StorageError};impl ProfileHost {+ /// A backend captured for one currently open profile's exact lease fence.+ /// Maintenance work must keep this backend together with the scopes it+ /// visits, so a later lease takeover cannot replace the captured epoch.+ ///+ /// Returns `None` when this profile host uses file leases and has no+ /// storage backend.+ pub(crate) fn storage_backend_for(+ &self,+ profile: &Profile,+ ) -> Result<Option<Arc<dyn StorageBackend>>, StorageError> {+ let Some(backend) = &self.backend else {+ return Ok(None);+ };+ Ok(Some(Arc::new(FencedBackend::for_fence(+ Arc::clone(backend),+ Arc::clone(profile.lease_fence()),+ ))))+ }+/// A host over `backend` when given (the shared registry and cluster/// leases), else as [`Self::new`]. Supplied backends are guarded by this/// host's profile fences for cron policy writes; an already-fenced backenddiff --git a/crates/openhuman-core/src/storage/fenced_backend.rs b/crates/openhuman-core/src/storage/fenced_backend.rsindex 341489c400..1bed199bf7 100644--- a/crates/openhuman-core/src/storage/fenced_backend.rs+++ b/crates/openhuman-core/src/storage/fenced_backend.rs@@ -1,685 +1,118 @@-//! [`FencedBackend`]: a storage backend whose writes pass the lease fence.+//! Scope-bound storage handles guarded by a profile lease condition.//!-//! Wraps any backend. Every scope it hands out is the inner backend's, with-//! the document, stream and blob handles wrapped so that each write first-//! asks the [`FenceRegistry`] for the scope's fence and runs only if that-//! fence passes ([`FenceRegistry::admit`]). Reads, `ensure_collection`-//! (idempotent schema) and scopes with no fence go straight through.-//!-//! A write the host check admits then goes through the inner backend's-//! fenced handles ([`StorageBackend::for_scope_fenced`] with-//! [`LeaseFence::driver_fence`](super::fence::LeaseFence::driver_fence)), so-//! the driver re-checks the lease record atomically with the write. A-//! driver refusal ([`ErrorKind::Fenced`]) latches the fence and surfaces as-//! [`FenceError::Superseded`](super::fence::FenceError::Superseded). Where-//! the driver cannot fence (no [`Capability::Fencing`], a write it answers-//! with `Unsupported(Fencing)`, or a lease store with no-//! record in the ports) the write runs after the host check alone.-//!-//! The fence is looked up per write, not when the scope is bound, because-//! long-lived consumers (the session store caches its per-agent handles)-//! must follow the profile as it is opened, fenced and re-opened.-//!-//! See [`super::fence`] for what the checks do and do not guarantee.+//! The driver evaluates the persisted lease predicate atomically with each+//! mutation. `FencedBackend` composes that predicate with any caller-supplied+//! condition, so an importer claim or other host condition cannot replace the+//! profile's authority. A captured backend keeps the exact lease epoch it was+//! created for; it never resolves a later registry entry for that profile.-use std::ops::Range;-use std::pin::Pin;-use std::sync::atomic::{AtomicBool, Ordering};-use std::sync::{Arc, Mutex};-use std::task::{Context, Poll};-use std::time::Duration;+use std::sync::Arc;-use async_trait::async_trait;-use serde_json::Value;-use tinystoragedrivers::{- Blob, BlobMeta, BlobStore, BlobStream, Capabilities, Capability, CollectionSpec, ErrorKind,- Filter, Page, Precondition, Query, ReadCheck, Result, SearchHit, Sort, StorageError,- StreamEntry, StreamStore, Version, Versioned, WriteOp, WriteResult,-};+use tinystoragedrivers::{Scope, Storage, StorageBackend, StorageError};+use tinystoragedrivers_types::WriteCondition;use super::fence::{FenceRegistry, LeaseFence};-use super::{DocumentStore, Scope, ScopedStorage, StorageBackend};-/// A backend whose writes are fenced. See the module docs.+/// A backend whose scope handles carry the applicable host lease condition.pub struct FencedBackend {inner: Arc<dyn StorageBackend>,- fences: Arc<FenceRegistry>,+ registry: Option<Arc<FenceRegistry>>,+ captured: Option<Arc<LeaseFence>>,}impl std::fmt::Debug for FencedBackend {fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {f.debug_struct("FencedBackend").field("inner", &self.inner)+ .field("captured", &self.captured).finish_non_exhaustive()}}impl FencedBackend {- /// `inner`, its writes checked against `fences`.+ /// Create a backend that resolves the current registered fence for each+ /// newly opened scope.pub fn new(inner: Arc<dyn StorageBackend>, fences: Arc<FenceRegistry>) -> Self {- Self { inner, fences }- }-}--impl FencedBackend {- /// `scoped`'s handles with every write passing the scope's fence.- fn wrap_scoped(&self, scope: &Scope, scoped: &ScopedStorage) -> ScopedStorage {- let guard = Guard {- scope: scope.clone(),- fences: Arc::clone(&self.fences),- backend: Some(Arc::clone(&self.inner)),- };- ScopedStorage::new(- scope.clone(),- scoped.driver(),- Arc::new(FencedDocuments {- inner: Arc::clone(scoped.documents()),- guard: guard.clone(),- }),- Arc::new(FencedStreams {- inner: Arc::clone(scoped.streams()),- guard: guard.clone(),- }),- Arc::new(FencedBlobs {- inner: Arc::clone(scoped.blobs()),- guard,- }),- )- }-}--/// `inner` fenced by the process's registry ([`super::fence::registry`]).-pub fn wrap(inner: Arc<dyn StorageBackend>) -> Arc<dyn StorageBackend> {- Arc::new(FencedBackend::new(inner, super::fence::registry()))-}--#[async_trait]-impl StorageBackend for FencedBackend {- fn driver(&self) -> &'static str {- self.inner.driver()- }-- fn capabilities(&self) -> Capabilities {- self.inner.capabilities()- }-- fn for_scope(&self, scope: &Scope) -> Result<ScopedStorage> {- let scoped = self.inner.for_scope(scope)?;- Ok(self.wrap_scoped(scope, &scoped))- }-- fn document_driver(&self) -> &'static str {- self.inner.document_driver()- }-- fn existing_schema(&self) -> Result<Arc<dyn StorageBackend>> {- Ok(Arc::new(Self {- inner: self.inner.existing_schema()?,- fences: Arc::clone(&self.fences),- }))- }-- async fn prepare_schema(&self) -> Result<()> {- self.inner.prepare_schema().await- }-- /// The driver's own fenced handles; the fence wrapper itself builds on- /// these, so they are not wrapped a second time.- fn for_scope_fenced(- &self,- scope: &Scope,- fence: &tinystoragedrivers::Fence,- ) -> Result<ScopedStorage> {- self.inner.for_scope_fenced(scope, fence)- }-- fn for_scope_generation(- &self,- scope: &Scope,- generation: tinystoragedrivers::ScopeGeneration,- ) -> Result<ScopedStorage> {- let scoped = self.inner.for_scope_generation(scope, generation)?;- Ok(self.wrap_scoped(scope, &scoped))- }-- fn for_scope_fenced_generation(- &self,- scope: &Scope,- generation: tinystoragedrivers::ScopeGeneration,- fence: &tinystoragedrivers::Fence,- ) -> Result<ScopedStorage> {- self.inner- .for_scope_fenced_generation(scope, generation, fence)- }-- async fn maintain(- &self,- budget: tinystoragedrivers::MaintenanceBudget,- ) -> Result<tinystoragedrivers::MaintenanceReport> {- self.inner.maintain(budget).await- }-- async fn checkpoint(&self, mode: tinystoragedrivers::Checkpoint) -> Result<()> {- self.inner.checkpoint(mode).await- }-- async fn scopes(&self, prefix: &str) -> Result<Vec<Scope>> {- self.inner.scopes(prefix).await- }-- async fn scopes_of_tenant(&self, tenant: &Scope) -> Result<Vec<Scope>> {- self.inner.scopes_of_tenant(tenant).await- }-- /// Reclaiming blobs that already read as absent changes nothing a reader- /// can see, so it needs no fence: it goes straight to the inner driver's- /// own implementation rather than the trait default over the fenced view.- async fn sweep_expired_blobs(&self, scope: &Scope) -> Result<u64> {- self.inner.sweep_expired_blobs(scope).await- }-}--#[derive(Clone)]-struct Guard {- scope: Scope,- fences: Arc<FenceRegistry>,- /// The inner backend, whose driver may enforce the fence.- backend: Option<Arc<dyn StorageBackend>>,-}--impl Guard {- /// The host check. `Ok(Some(..))` when the driver should enforce the- /// fence too: the fence and the scope's fenced handles to write through.- async fn admit(&self, op: &'static str) -> Result<Option<(Arc<LeaseFence>, ScopedStorage)>> {- let Some(lease) = self.fences.admit(self.scope.as_str(), op).await? else {- return Ok(None);- };- let Some(backend) = &self.backend else {- return Ok(None);- };- if !backend.capabilities().contains(Capability::Fencing) {- return Ok(None);- }- let Some(fence) = lease.driver_fence() else {- return Ok(None);- };- match backend.for_scope_fenced(&self.scope, &fence) {- Ok(scoped) => Ok(Some((lease, scoped))),- Err(error) if unfenceable(&error) => Ok(None),- Err(error) => Err(error),+ Self {+ inner,+ registry: Some(fences),+ captured: None,}}- /// What a driver-fenced write's refusal means: a [`ErrorKind::Fenced`]- /// becomes the latched fence's error; anything else passes through.- async fn settle<T>(- &self,- lease: &LeaseFence,- op: &'static str,- outcome: Result<T>,- ) -> Result<T> {- match outcome {- Err(error) if error.kind() == ErrorKind::Fenced => {- Err(self.fences.driver_refused(lease, op).await)- }- other => other,- }- }-}--/// The driver cannot make this write atomic with the fence.-fn unfenceable(error: &StorageError) -> bool {- error.kind() == ErrorKind::Unsupported(Capability::Fencing)-}--/// One fenced write: the host check, then `$port.$method(args)` through the-/// driver's fenced handles when it can enforce the fence, else (or when it-/// answers `Unsupported(Fencing)` for this write) through `$self.inner`.-/// Arguments are cloned for the fenced attempt so the fallback can reuse-/// them.-macro_rules! fenced_write {- ($self:ident, $op:literal, $port:ident . $method:ident ( $($arg:expr),* $(,)? )) => {{- match $self.guard.admit($op).await? {- None => $self.inner.$method($($arg),*).await,- Some((lease, scoped)) => {- // `&str` and `Copy` arguments clone trivially; the owned ones- // must survive for the fallback.- #[allow(clippy::clone_on_copy)]- let outcome = scoped.$port().$method($(Clone::clone(&$arg)),*).await;- match outcome {- Err(error) if unfenceable(&error) => {- tracing::debug!(- target: "openhuman::storage::fence",- op = $op,- "[storage][fence] driver cannot fence this write; host check only"- );- $self.inner.$method($($arg),*).await- }- outcome => $self.guard.settle(&lease, $op, outcome).await,- }- }+ /// Create a backend permanently tied to `fence`'s lease epoch.+ ///+ /// This is for work (such as maintenance) that must retain the authority+ /// admitted when a particular profile was captured. It fails closed for+ /// scopes outside the captured fence, and does not consult or follow a+ /// replacement fence in the registry.+ pub fn for_fence(inner: Arc<dyn StorageBackend>, fence: Arc<LeaseFence>) -> Self {+ Self {+ inner,+ registry: None,+ captured: Some(fence),}- }};-}--struct FencedDocuments {- inner: Arc<dyn DocumentStore>,- guard: Guard,-}--impl std::fmt::Debug for FencedDocuments {- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- f.debug_struct("FencedDocuments")- .field("inner", &self.inner)- .finish_non_exhaustive()- }-}--#[async_trait]-impl DocumentStore for FencedDocuments {- fn capabilities(&self) -> Capabilities {- self.inner.capabilities()- }-- async fn ensure_collection(&self, spec: &CollectionSpec) -> Result<()> {- self.inner.ensure_collection(spec).await- }-- async fn get(&self, collection: &str, id: &str) -> Result<Option<Versioned<Value>>> {- self.inner.get(collection, id).await- }-- async fn put(- &self,- collection: &str,- id: &str,- doc: Value,- precondition: Precondition,- ) -> Result<Version> {- fenced_write!(- self,- "documents.put",- documents.put(collection, id, doc, precondition)- )- }-- /// Forwarded (and fenced): without it the trait default refuses a write that- /// declares a schema version or expiry, which is every owner's write.- async fn put_with(- &self,- collection: &str,- id: &str,- doc: Value,- precondition: Precondition,- options: tinystoragedrivers::WriteOptions,- ) -> Result<Version> {- fenced_write!(- self,- "documents.put_with",- documents.put_with(collection, id, doc, precondition, options)- )- }-- async fn delete(&self, collection: &str, id: &str, precondition: Precondition) -> Result<bool> {- fenced_write!(- self,- "documents.delete",- documents.delete(collection, id, precondition)- )- }-- async fn query(&self, collection: &str, query: &Query) -> Result<Page<Versioned<Value>>> {- self.inner.query(collection, query).await- }-- async fn count(&self, collection: &str, filter: &Filter) -> Result<u64> {- self.inner.count(collection, filter).await}- async fn delete_where(&self, collection: &str, filter: &Filter) -> Result<u64> {- fenced_write!(- self,- "documents.delete_where",- documents.delete_where(collection, filter)- )- }-- async fn claim(- &self,- collection: &str,- filter: &Filter,- sort: &[Sort],- patch: &Value,- ) -> Result<Option<Versioned<Value>>> {- fenced_write!(- self,- "documents.claim",- documents.claim(collection, filter, sort, patch)- )- }-- async fn atomic_batch(&self, ops: Vec<WriteOp>) -> Result<Vec<WriteResult>> {- fenced_write!(self, "documents.atomic_batch", documents.atomic_batch(ops))- }-- async fn atomic_batch_checked(- &self,- checks: Vec<ReadCheck>,- ops: Vec<WriteOp>,- ) -> Result<Vec<WriteResult>> {- fenced_write!(- self,- "documents.atomic_batch_checked",- documents.atomic_batch_checked(checks, ops)- )- }-- async fn search(&self, collection: &str, text: &str, limit: usize) -> Result<Vec<SearchHit>> {- self.inner.search(collection, text, limit).await- }-- async fn drop_collection(&self, collection: &str) -> Result<()> {- fenced_write!(- self,- "documents.drop_collection",- documents.drop_collection(collection)- )- }-- async fn watch(- &self,- collection: &str,- filter: &Filter,- options: &tinystoragedrivers::WatchOptions,- ) -> Result<Box<dyn tinystoragedrivers::DocumentWatch>> {- self.inner.watch(collection, filter, options).await- }-- async fn validate_collection_spec(&self, required: &CollectionSpec) -> Result<()> {- self.inner.validate_collection_spec(required).await- }-- async fn collections(&self, prefix: &str) -> Result<Vec<String>> {- self.inner.collections(prefix).await- }-}--struct FencedStreams {- inner: Arc<dyn StreamStore>,- guard: Guard,-}--impl std::fmt::Debug for FencedStreams {- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- f.debug_struct("FencedStreams")- .field("inner", &self.inner)- .finish_non_exhaustive()- }-}--#[async_trait]-impl StreamStore for FencedStreams {- async fn append(&self, stream: &str, value: Value) -> Result<u64> {- fenced_write!(self, "streams.append", streams.append(stream, value))- }-- async fn append_batch(&self, stream: &str, values: Vec<Value>) -> Result<u64> {- fenced_write!(- self,- "streams.append_batch",- streams.append_batch(stream, values)- )- }-- /// Forwarded (and fenced): without it the trait default answers- /// `Unsupported(ConditionalStreamAppend)` even on a driver that has it,- /// which refuses every conversation append.- async fn append_batch_if_offset(- &self,- stream: &str,- expected_next_offset: u64,- values: Vec<Value>,- ) -> Result<u64> {- fenced_write!(- self,- "streams.append_batch_if_offset",- streams.append_batch_if_offset(stream, expected_next_offset, values)- )- }-- async fn read_window(&self, stream: &str, from: u64, limit: usize) -> Result<Vec<StreamEntry>> {- self.inner.read_window(stream, from, limit).await- }-- async fn len(&self, stream: &str) -> Result<u64> {- self.inner.len(stream).await- }-- async fn truncate_before(&self, stream: &str, offset: u64) -> Result<u64> {- fenced_write!(- self,- "streams.truncate_before",- streams.truncate_before(stream, offset)- )- }-- async fn delete_stream(&self, stream: &str) -> Result<bool> {- fenced_write!(self, "streams.delete_stream", streams.delete_stream(stream))- }-- async fn streams(&self, prefix: &str) -> Result<Vec<String>> {- self.inner.streams(prefix).await- }-- async fn info(&self, stream: &str) -> Result<Option<tinystoragedrivers::StreamInfo>> {- self.inner.info(stream).await- }-- /// Forwarded (and fenced): sealing a finished stream is a write.- async fn seal(&self, stream: &str) -> Result<tinystoragedrivers::SealOutcome> {- fenced_write!(self, "streams.seal", streams.seal(stream))- }-- async fn delete_sealed_stream(&self, stream: &str, sealed_ms: i64) -> Result<bool> {- fenced_write!(- self,- "streams.delete_sealed_stream",- streams.delete_sealed_stream(stream, sealed_ms)- )- }-}--struct FencedBlobs {- inner: Arc<dyn BlobStore>,- guard: Guard,-}--/// Two handles to one stream, used only to recover the input when a native-/// fenced handle rejects streaming before it polls the reader.-#[derive(Clone)]-struct SharedBlobReader {- reader: Arc<Mutex<tinystoragedrivers::BlobReader>>,- polled: Arc<AtomicBool>,-}--impl tokio::io::AsyncRead for SharedBlobReader {- fn poll_read(- self: Pin<&mut Self>,- cx: &mut Context<'_>,- buf: &mut tokio::io::ReadBuf<'_>,- ) -> Poll<std::io::Result<()>> {- let this = self.get_mut();- this.polled.store(true, Ordering::SeqCst);- let mut reader = match this.reader.lock() {- Ok(reader) => reader,- Err(_) => {- return Poll::Ready(Err(std::io::Error::other(- "shared blob reader lock was poisoned",- )));+ fn condition_for(&self, scope: &Scope) -> Result<Option<WriteCondition>, StorageError> {+ let fence = if let Some(captured) = &self.captured {+ if !captured.covers(scope.as_str()) {+ return Err(StorageError::backend(+ "captured profile storage backend cannot open an out-of-fence scope",+ ));}+ Some(Arc::clone(captured))+ } else {+ self.registry+ .as_ref()+ .and_then(|registry| registry.lookup(scope.as_str()))};- reader.as_mut().poll_read(cx, buf)- }-}-fn shared_blob_readers(- reader: tinystoragedrivers::BlobReader,-) -> (- tinystoragedrivers::BlobReader,- tinystoragedrivers::BlobReader,- Arc<AtomicBool>,-) {- let reader = Arc::new(Mutex::new(reader));- let polled = Arc::new(AtomicBool::new(false));- let handle = || {- Box::pin(SharedBlobReader {- reader: Arc::clone(&reader),- polled: Arc::clone(&polled),- }) as tinystoragedrivers::BlobReader- };- (handle(), handle(), polled)-}--impl std::fmt::Debug for FencedBlobs {- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {- f.debug_struct("FencedBlobs")- .field("inner", &self.inner)- .finish_non_exhaustive()- }+ let Some(fence) = fence else {+ return Ok(None);+ };+ fence+ .check_local(+ self.registry+ .as_ref()+ .map_or_else(super::fence::system_now_ms, |registry| registry.now_ms()),+ )+ .map_err(|error| error.into_storage())?;+ fence.write_condition().map(Some).ok_or_else(|| {+ StorageError::backend(+ "profile lease has no atomic storage condition; refusing unguarded handles",+ )+ })+ }+}++/// Wrap the process backend with its shared fence registry.+pub fn wrap(inner: Arc<dyn StorageBackend>) -> Arc<dyn StorageBackend> {+ Arc::new(FencedBackend::new(inner, super::fence::registry()))}-#[async_trait]-impl BlobStore for FencedBlobs {- fn max_key_len(&self) -> usize {- self.inner.max_key_len()- }-- /// The driver's abilities, minus presigned URLs: a presigned PUT is a write- /// the fence never sees, so the view does not offer them.- fn capabilities(&self) -> Capabilities {- self.inner.capabilities().without(Capability::PresignedUrls)- }-- async fn put_expiring(- &self,- key: &str,- bytes: Vec<u8>,- content_type: Option<&str>,- ttl: Duration,- ) -> Result<BlobMeta> {- fenced_write!(- self,- "blobs.put_expiring",- blobs.put_expiring(key, bytes, content_type, ttl)- )- }-- async fn get_stream(&self, key: &str) -> Result<Option<BlobStream>> {- self.inner.get_stream(key).await+impl StorageBackend for FencedBackend {+ fn capabilities(&self) -> tinystoragedrivers_types::Capabilities {+ self.inner.capabilities()}- async fn put_stream(- &self,- key: &str,- reader: tinystoragedrivers::BlobReader,- len: u64,- content_type: Option<&str>,- ) -> Result<BlobMeta> {- match self.guard.admit("blobs.put_stream").await? {- None => self.inner.put_stream(key, reader, len, content_type).await,- Some((lease, scoped)) => {- let (attempt, fallback, polled) = shared_blob_readers(reader);- let outcome = scoped- .blobs()- .put_stream(key, attempt, len, content_type)- .await;- match outcome {- Err(error) if unfenceable(&error) && !polled.load(Ordering::SeqCst) => {- tracing::debug!(- target: "openhuman::storage::fence",- op = "blobs.put_stream",- "[storage][fence] driver cannot fence this stream write; host check only"- );- self.inner- .put_stream(key, fallback, len, content_type)- .await- }- outcome => self.guard.settle(&lease, "blobs.put_stream", outcome).await,- }- }+ fn for_scope(&self, scope: &Scope) -> Result<Storage, StorageError> {+ match self.condition_for(scope)? {+ Some(condition) => self.inner.for_scope_conditioned(scope, &condition),+ None => self.inner.for_scope(scope),}}- async fn put_stream_expiring(+ fn for_scope_conditioned(&self,- key: &str,- reader: tinystoragedrivers::BlobReader,- len: u64,- content_type: Option<&str>,- ttl: Duration,- ) -> Result<BlobMeta> {- match self.guard.admit("blobs.put_stream_expiring").await? {- None => {- self.inner- .put_stream_expiring(key, reader, len, content_type, ttl)- .await- }- Some((lease, scoped)) => {- let (attempt, fallback, polled) = shared_blob_readers(reader);- let outcome = scoped- .blobs()- .put_stream_expiring(key, attempt, len, content_type, ttl)- .await;- match outcome {- Err(error) if unfenceable(&error) && !polled.load(Ordering::SeqCst) => {- tracing::debug!(- target: "openhuman::storage::fence",- op = "blobs.put_stream_expiring",- "[storage][fence] driver cannot fence this stream write; host check only"- );- self.inner- .put_stream_expiring(key, fallback, len, content_type, ttl)- .await- }- outcome => {- self.guard- .settle(&lease, "blobs.put_stream_expiring", outcome)- .await- }- }- }+ scope: &Scope,+ condition: &WriteCondition,+ ) -> Result<Storage, StorageError> {+ match self.condition_for(scope)? {+ Some(fence) => self+ .inner+ .for_scope_conditioned(scope, &fence.and(condition.clone())?),+ None => self.inner.for_scope_conditioned(scope, condition),}}-- async fn presign_get(&self, key: &str, ttl: Duration) -> Result<String> {- self.inner.presign_get(key, ttl).await- }-- async fn put(&self, key: &str, bytes: Vec<u8>, content_type: Option<&str>) -> Result<BlobMeta> {- fenced_write!(self, "blobs.put", blobs.put(key, bytes, content_type))- }-- async fn get(&self, key: &str) -> Result<Option<Blob>> {- self.inner.get(key).await- }-- async fn get_range(&self, key: &str, range: Range<u64>) -> Result<Option<Vec<u8>>> {- self.inner.get_range(key, range).await- }-- async fn head(&self, key: &str) -> Result<Option<BlobMeta>> {- self.inner.head(key).await- }-- async fn delete(&self, key: &str) -> Result<bool> {- fenced_write!(self, "blobs.delete", blobs.delete(key))- }-- async fn list(&self, prefix: &str) -> Result<Vec<BlobMeta>> {- self.inner.list(prefix).await- }}--#[cfg(test)]-#[path = "fenced_backend_tests.rs"]-mod tests;