Struct opendal::Operator

pub struct Operator { /* private fields */ }

User-facing APIs for object and object streams.

Implementations

impl Operator

pub fn new(accessor: Arc<dyn Accessor>) -> Self

Create a new operator.

Example

Read more backend init examples in examples.

use std::sync::Arc;

/// Example for initiating a fs backend.
use anyhow::Result;
use opendal::services::fs;
use opendal::services::fs::Builder;
use opendal::Accessor;
use opendal::Object;
use opendal::Operator;

#[tokio::main]
async fn main() -> Result<()> {
    // Create fs backend builder.
    let mut builder: Builder = fs::Backend::build();
    // Set the root for fs, all operations will happen under this root.
    //
    // NOTE: the root must be absolute path.
    builder.root("/tmp");
    // Build the `Accessor`.
    let accessor: Arc<dyn Accessor> = builder.finish().await?;

    // `Accessor` provides the low level APIs, we will use `Operator` normally.
    let op: Operator = Operator::new(accessor);

    // Create an object handle to start operation on object.
    let _: Object = op.object("test_file");

    Ok(())
}

pub fn layer(self, layer: impl Layer) -> Self

Create a new layer.

pub fn with_backoff(
    self,
    backoff: impl Backoff + Send + Sync + Debug + 'static
) -> Self

Configure backoff for operators

This function only provided if feature retry is enabled.

Examples

use backon::ExponentialBackoff;
use opendal::Operator;

let op = Operator::new(accessor).with_backoff(ExponentialBackoff::default());
// All operations will be retried if the error is retryable
let _ = op.object("test_file").read();

pub fn metadata(&self) -> AccessorMetadata

Get metadata of underlying accessor.

Examples

use opendal::Operator;

let op = Operator::new(accessor);
let meta = op.metadata();

pub fn object(&self, path: &str) -> Object

Create a new Object handle to take operations.

pub async fn check(&self, path: &str) -> Result<()>

Check if this operator can work correctly.

We will send a real stat request to path and return any errors we met.

use opendal::Operator;

let op = Operator::new(accessor);
op.check(".opendal").await?;

Trait Implementations

impl Clone for Operator

fn clone(&self) -> Operator

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.