Class: OpenDAL::Operator

Inherits:
Object
  • Object
show all
Defined in:
src/operator.rs

Overview

The entrypoint for operating with file services and files.

Instance Method Summary collapse

Instance Method Details

#capability ⇒ Capability

Gets capabilities of the current operator

Returns:



116
117
118
119
 
# File 'src/operator.rs', line 116

fn capability(&self) -> Result<Capability, Error> {
    let capability = self.0.info().full_capability();
    Ok(Capability::new(capability))
}

#copy(from, to) ⇒ nil

Copies a file from from to to.

Parameters:

  • from (String) —

    a file path

  • to (String) —

    a file path

Returns:

  • (nil) 


189
190
191
192
193
194
 
# File 'src/operator.rs', line 189

fn copy(ruby: &Ruby, rb_self: &Self, from: String, to: String) -> Result<(), Error> {
    rb_self
        .0
        .copy(&from, &to)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#create_dir(path) ⇒ nil

Creates directory recursively similar as mkdir -p The ending path must be /. Otherwise, OpenDAL throws NotADirectory error.

Parameters:

  • path (String)

Returns:

  • (nil) 


127
128
129
130
131
132
 
# File 'src/operator.rs', line 127

fn create_dir(ruby: &Ruby, rb_self: &Self, path: String) -> Result<(), Error> {
    rb_self
        .0
        .create_dir(&path)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#delete(path) ⇒ nil

Deletes given path

Parameters:

  • path (String)

Returns:

  • (nil) 


139
140
141
142
143
144
 
# File 'src/operator.rs', line 139

fn delete(ruby: &Ruby, rb_self: &Self, path: String) -> Result<(), Error> {
    rb_self
        .0
        .delete(&path)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#exist?(path) ⇒ Boolean

Returns if this path exists

Parameters:

  • path (String)

Returns:

  • (Boolean) 


151
152
153
154
155
156
 
# File 'src/operator.rs', line 151

fn exists(ruby: &Ruby, rb_self: &Self, path: String) -> Result<bool, Error> {
    rb_self
        .0
        .exists(&path)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#list(limit: nil, start_after: nil, recursive: nil) ⇒ Lister

Lists the directory.

Parameters:

  • limit (usize, nil) (defaults to: nil) —

    per-request max results

  • start_after (String, nil) (defaults to: nil) —

    the specified key to start listing from.

  • recursive (Boolean, nil) (defaults to: nil) —

    lists the directory recursively.

Returns:



215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'src/operator.rs', line 215

pub fn list(ruby: &Ruby, rb_self: &Self, args: &[Value]) -> Result<Lister, Error> {
    let args = scan_args::<(String,), (), (), (), _, ()>(args)?;
    let (path,) = args.required;
    let kwargs = get_kwargs::<_, (), (Option<usize>, Option<String>, Option<bool>), ()>(
        args.keywords,
        &[],
        &["limit", "start_after", "recursive"],
    )?;
    let (limit, start_after, recursive) = kwargs.optional;

    let mut builder = rb_self.0.clone().lister_with(&path);

    if let Some(limit) = limit {
        builder = builder.limit(limit);
    }

    if let Some(start_after) = start_after {
        builder = builder.start_after(start_after.as_str());
    }

    if let Some(true) = recursive {
        builder = builder.recursive(true);
    }

    let lister = builder
        .call()
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))?;

    Ok(Lister::new(lister))
}

#open(path, mode) ⇒ OpenDAL::IO

Opens a IO-like reader for the given path.

Parameters:

  • path (String) —

    file path

  • mode (String) —

    operation mode, e.g., r, w, or rb.

Returns:

Raises:

  • (ArgumentError) —

    invalid mode, or when the mode is not unique



203
204
205
206
 
# File 'src/operator.rs', line 203

fn open(ruby: &Ruby, rb_self: &Self, path: String, mode: String) -> Result<Io, Error> {
    let operator = rb_self.0.clone();
    Io::new(ruby, operator, path, mode)
}

#read(path) ⇒ Metadata

Gets current path's metadata without cache directly.

Parameters:

  • path

Returns:



77
78
79
80
81
82
83
 
# File 'src/operator.rs', line 77

fn read(ruby: &Ruby, rb_self: &Self, path: String) -> Result<bytes::Bytes, Error> {
    let buffer = rb_self
        .0
        .read(&path)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))?;
    Ok(buffer.to_bytes())
}

#remove_all(path) ⇒ nil

Removes the path and all nested directories and files recursively

Parameters:

  • path (String)

Returns:

  • (nil) 


176
177
178
179
180
181
 
# File 'src/operator.rs', line 176

fn remove_all(ruby: &Ruby, rb_self: &Self, path: String) -> Result<(), Error> {
    rb_self
        .0
        .remove_all(&path)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#rename(from, to) ⇒ nil

Renames a file from from to to

Parameters:

  • from (String) —

    a file path

  • to (String) —

    a file path

Returns:

  • (nil) 


164
165
166
167
168
169
 
# File 'src/operator.rs', line 164

fn rename(ruby: &Ruby, rb_self: &Self, from: String, to: String) -> Result<(), Error> {
    rb_self
        .0
        .rename(&from, &to)
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}

#write(path, buffer) ⇒ nil

Writes string into given path.

Parameters:

  • path (String)
  • buffer (String)

Returns:

  • (nil) 


91
92
93
94
95
96
97
 
# File 'src/operator.rs', line 91

fn write(ruby: &Ruby, rb_self: &Self, path: String, bs: RString) -> Result<(), Error> {
    rb_self
        .0
        .write(&path, bs.to_bytes())
        .map(|_| ())
        .map_err(|err| Error::new(ruby.exception_runtime_error(), err.to_string()))
}