Struct opendal::Operator

pub struct Operator { /* private fields */ }

User-facing APIs for object and object streams.

Implementations

impl Operator

pub fn new(accessor: impl Accessor) -> Self

Create a new operator.

Examples

Read more backend init examples in examples.

#[tokio::main]
async fn main() -> Result<()> {
    // Create fs backend builder.
    let mut builder = fs::Builder::default();
    // Set the root for fs, all operations will happen under this root.
    //
    // NOTE: the root must be absolute path.
    builder.root("/tmp");

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

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

    Ok(())
}

pub fn from_iter(
    scheme: Scheme,
    it: impl Iterator<Item = (String, String)> + 'static
) -> Result<Self>

Create a new operator from iter.

Please refer different backends for detailed config options.

Behavior

• All input key must be lower_case
• Boolean values will be checked by its existences and non-empty value. on, yes, true, off, no, false will all be treated as true To disable a flag, please set value to empty.

Examples

#[tokio::main]
async fn main() -> Result<()> {
    let op: Operator = Operator::from_iter(
        Scheme::Fs,
        [("root".to_string(), "/tmp".to_string())].into_iter(),
    )?;

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

    Ok(())
}

pub fn from_env(scheme: Scheme) -> Result<Self>

Create a new operator from env.

Behavior

• Environment keys are case-insensitive, they will be converted to lower case internally.
• Environment values are case-sensitive, no sanity will be executed on them.
• Boolean values will be checked by its existences and non-empty value. on, yes, true, off, no, false will all be treated as true To disable a flag, please set value to empty.

Examples

Setting environment:

export OPENDAL_FS_ROOT=/tmp

Please refer different backends for detailed config options.

#[tokio::main]
async fn main() -> Result<()> {
    // `Accessor` provides the low level APIs, we will use `Operator` normally.
    let op: Operator = Operator::from_env(Scheme::Fs)?;

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

Examples

This examples needs feature retry enabled.

use opendal::Operator;
use opendal::Layer;

let accessor = fs::Backend::build().finish().await?;
let op = Operator::new(accessor).layer(new_layer);
// All operations will go through the new_layer
let _ = op.object("test_file").read();

pub fn metadata(&self) -> AccessorMetadata

Get metadata of underlying accessor.

Examples

use opendal::Operator;
use opendal::Scheme;

let op = Operator::from_env(Scheme::Fs)?;
let meta = op.metadata();

pub fn batch(&self) -> BatchOperator

Create a new batch operator handle to take batch operations like walk and remove.

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

Create a new Object handle to take operations.

pub async fn check(&self) -> Result<()>

Check if this operator can work correctly.

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

use opendal::Operator;
use opendal::Scheme;

let op = Operator::from_env(Scheme::Fs)?;
op.check().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.

impl Debug for Operator

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

Formats the value using the given formatter.

impl<A> From<A> for Operatorwhere
    A: Accessor + 'static,

fn from(accessor: A) -> Self

Converts to this type from the input type.