Trait opendal::raw::Accessor

pub trait Accessor: Send + Sync + Debug + Unpin + 'static {
    type Reader: Read;
    type BlockingReader: BlockingRead;

    fn metadata(&self) -> AccessorMetadata { ... }
    fn create<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpCreate
    ) -> Pin<Box<dyn Future<Output = Result<RpCreate>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn read<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpRead
    ) -> Pin<Box<dyn Future<Output = Result<(RpRead, Self::Reader)>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn write<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpWrite,
        r: Reader
    ) -> Pin<Box<dyn Future<Output = Result<RpWrite>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn stat<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpStat
    ) -> Pin<Box<dyn Future<Output = Result<RpStat>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn delete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpDelete
    ) -> Pin<Box<dyn Future<Output = Result<RpDelete>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpList
    ) -> Pin<Box<dyn Future<Output = Result<(RpList, ObjectPager)>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign> { ... }
    fn create_multipart<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpCreateMultipart
    ) -> Pin<Box<dyn Future<Output = Result<RpCreateMultipart>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn write_multipart<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpWriteMultipart,
        r: Reader
    ) -> Pin<Box<dyn Future<Output = Result<RpWriteMultipart>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn complete_multipart<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpCompleteMultipart
    ) -> Pin<Box<dyn Future<Output = Result<RpCompleteMultipart>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn abort_multipart<'life0, 'life1, 'async_trait>(
        &'life0 self,
        path: &'life1 str,
        args: OpAbortMultipart
    ) -> Pin<Box<dyn Future<Output = Result<RpAbortMultipart>> + Send + 'async_trait>>
    where
        Self: 'async_trait,
        'life0: 'async_trait,
        'life1: 'async_trait,
    { ... }
    fn blocking_create(&self, path: &str, args: OpCreate) -> Result<RpCreate> { ... }
    fn blocking_read(
        &self,
        path: &str,
        args: OpRead
    ) -> Result<(RpRead, Self::BlockingReader)> { ... }
    fn blocking_write(
        &self,
        path: &str,
        args: OpWrite,
        r: BlockingReader
    ) -> Result<RpWrite> { ... }
    fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat> { ... }
    fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete> { ... }
    fn blocking_list(
        &self,
        path: &str,
        args: OpList
    ) -> Result<(RpList, BlockingObjectPager)> { ... }
}

Underlying trait of all backends for implementors.

Note

Only service implementor should care about this trait, users need to use Operator instead.

Operations

Name	Capability
metadata	-
create	-
read	-
write	-
delete	-
list	-
presign	Presign
create_multipart	Multipart
write_multipart	Multipart
complete_multipart	Multipart
abort_multipart	Multipart
blocking_create	Blocking
blocking_read	Blocking
blocking_write	Blocking
blocking_delete	Blocking
blocking_list	Blocking

• Path in args will all be normalized into the same style, services should handle them based on services’ requirement.
  • Path that ends with / means it’s Dir, otherwise, it’s File.
  • Root dir is /
  • Path will never be empty.
• Operations without capability requirement like metadata, create are basic operations.
  • All services must implement them.
  • Use unimplemented!() if not implemented or can’t implement.
• Operations with capability requirement like presign are optional operations.
  • Services can implement them based on services capabilities.
  • The default implementation should return std::io::ErrorKind::Unsupported.

Required Associated Types

type Reader: Read

Reader is the associated reader the could return in read operation.

type BlockingReader: BlockingRead

BlockingReader is the associated reader that could return in blocking_read operation.

Provided Methods

fn metadata(&self) -> AccessorMetadata

Invoke the metadata operation to get metadata of accessor.

fn create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCreate
) -> Pin<Box<dyn Future<Output = Result<RpCreate>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the create operation on the specified path

Behavior

• Input path MUST match with ObjectMode, DON’T NEED to check object mode.
• Create on existing dir SHOULD succeed.
• Create on existing file SHOULD overwrite and truncate.

fn read<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpRead
) -> Pin<Box<dyn Future<Output = Result<(RpRead, Self::Reader)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the read operation on the specified path, returns a ObjectReader if operate successful.

Behavior

• Input path MUST be file path, DON’T NEED to check object mode.
• The returning contnet length may be smaller than the range specifed.

fn write<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpWrite,
    r: Reader
) -> Pin<Box<dyn Future<Output = Result<RpWrite>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the write operation on the specified path, returns a written size if operate successful.

Behavior

• Input path MUST be file path, DON’T NEED to check object mode.

fn stat<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpStat
) -> Pin<Box<dyn Future<Output = Result<RpStat>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the stat operation on the specified path.

Behavior

• stat empty path means stat backend’s root path.
• stat a path endswith “/” means stating a dir.
• mode and content_length must be set.

fn delete<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpDelete
) -> Pin<Box<dyn Future<Output = Result<RpDelete>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the delete operation on the specified path.

Behavior

• delete is an idempotent operation, it’s safe to call Delete on the same path multiple times.
• delete SHOULD return Ok(()) if the path is deleted successfully or not exist.

fn list<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpList
) -> Pin<Box<dyn Future<Output = Result<(RpList, ObjectPager)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the list operation on the specified path.

Behavior

• Input path MUST be dir path, DON’T NEED to check object mode.
• List non-exist dir should return Empty.

fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign>

Invoke the presign operation on the specified path.

Behavior

• Require capability: Presign
• This API is optional, return std::io::ErrorKind::Unsupported if not supported.

fn create_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCreateMultipart
) -> Pin<Box<dyn Future<Output = Result<RpCreateMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the create_multipart operation on the specified path.

Behavior

• Require capability: Multipart
• This op returns a upload_id which is required to for following APIs.

fn write_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpWriteMultipart,
    r: Reader
) -> Pin<Box<dyn Future<Output = Result<RpWriteMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the write_multipart operation on the specified path.

Behavior

• Require capability: Multipart

fn complete_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCompleteMultipart
) -> Pin<Box<dyn Future<Output = Result<RpCompleteMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the complete_multipart operation on the specified path.

Behavior

• Require capability: Multipart

fn abort_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpAbortMultipart
) -> Pin<Box<dyn Future<Output = Result<RpAbortMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

Invoke the abort_multipart operation on the specified path.

Behavior

• Require capability: Multipart

fn blocking_create(&self, path: &str, args: OpCreate) -> Result<RpCreate>

Invoke the blocking_create operation on the specified path.

This operation is the blocking version of Accessor::create

Behavior

• Require capability: Blocking

fn blocking_read(
    &self,
    path: &str,
    args: OpRead
) -> Result<(RpRead, Self::BlockingReader)>

Invoke the blocking_read operation on the specified path.

This operation is the blocking version of Accessor::read

Behavior

• Require capability: Blocking

fn blocking_write(
    &self,
    path: &str,
    args: OpWrite,
    r: BlockingReader
) -> Result<RpWrite>

Invoke the blocking_write operation on the specified path.

This operation is the blocking version of Accessor::write

Behavior

• Require capability: Blocking

fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat>

Invoke the blocking_stat operation on the specified path.

This operation is the blocking version of Accessor::stat

Behavior

• Require capability: Blocking

fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete>

Invoke the blocking_delete operation on the specified path.

This operation is the blocking version of Accessor::delete

Behavior

• Require capability: Blocking

fn blocking_list(
    &self,
    path: &str,
    args: OpList
) -> Result<(RpList, BlockingObjectPager)>

Invoke the blocking_list operation on the specified path.

This operation is the blocking version of Accessor::list

Behavior

• Require capability: Blocking
• List non-exist dir should return Empty.

Implementations on Foreign Types

impl<T: Accessor> Accessor for Arc<T>

All functions in Accessor only requires &self, so it’s safe to implement Accessor for Arc<dyn Accessor>.

type Reader = <T as Accessor>::Reader

type BlockingReader = <T as Accessor>::BlockingReader

fn metadata(&self) -> AccessorMetadata

fn create<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCreate
) -> Pin<Box<dyn Future<Output = Result<RpCreate>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn read<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpRead
) -> Pin<Box<dyn Future<Output = Result<(RpRead, Self::Reader)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn write<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpWrite,
    r: Reader
) -> Pin<Box<dyn Future<Output = Result<RpWrite>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn stat<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpStat
) -> Pin<Box<dyn Future<Output = Result<RpStat>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn delete<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpDelete
) -> Pin<Box<dyn Future<Output = Result<RpDelete>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn list<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpList
) -> Pin<Box<dyn Future<Output = Result<(RpList, ObjectPager)>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn presign(&self, path: &str, args: OpPresign) -> Result<RpPresign>

fn create_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCreateMultipart
) -> Pin<Box<dyn Future<Output = Result<RpCreateMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn write_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpWriteMultipart,
    r: Reader
) -> Pin<Box<dyn Future<Output = Result<RpWriteMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn complete_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpCompleteMultipart
) -> Pin<Box<dyn Future<Output = Result<RpCompleteMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn abort_multipart<'life0, 'life1, 'async_trait>(
    &'life0 self,
    path: &'life1 str,
    args: OpAbortMultipart
) -> Pin<Box<dyn Future<Output = Result<RpAbortMultipart>> + Send + 'async_trait>>where
    Self: 'async_trait,
    'life0: 'async_trait,
    'life1: 'async_trait,

fn blocking_create(&self, path: &str, args: OpCreate) -> Result<RpCreate>

fn blocking_read(
    &self,
    path: &str,
    args: OpRead
) -> Result<(RpRead, Self::BlockingReader)>

fn blocking_write(
    &self,
    path: &str,
    args: OpWrite,
    r: BlockingReader
) -> Result<RpWrite>

fn blocking_stat(&self, path: &str, args: OpStat) -> Result<RpStat>

fn blocking_delete(&self, path: &str, args: OpDelete) -> Result<RpDelete>

fn blocking_list(
    &self,
    path: &str,
    args: OpList
) -> Result<(RpList, BlockingObjectPager)>

Implementors

impl Accessor for FusedAccessor

type Reader = Box<dyn Read + 'static, Global>

type BlockingReader = Box<dyn BlockingRead + 'static, Global>

impl<L: LayeredAccessor> Accessor for L

type Reader = <L as LayeredAccessor>::Reader

type BlockingReader = <L as LayeredAccessor>::BlockingReader

impl<S: Adapter> Accessor for Backend<S>

type Reader = Cursor

type BlockingReader = Cursor