Struct guestfs::Handle

pub struct Handle { /* fields omitted */ }

Methods

impl Handle

pub fn create() -> Result<Handle, Error>

pub fn create_flags(flags: CreateFlags) -> Result<Handle, Error>

impl Handle

pub fn acl_delete_def_file(&self, dir: &str) -> Result<(), Error>

delete the default POSIX ACL of a directory

pub fn acl_get_file(&self, path: &str, acltype: &str) -> Result<String, Error>

get the POSIX ACL attached to a file

pub fn acl_set_file(
    &self,
    path: &str,
    acltype: &str,
    acl: &str
) -> Result<(), Error>

set the POSIX ACL attached to a file

pub fn add_cdrom(&self, filename: &str) -> Result<(), Error>

add a CD-ROM disk image to examine

pub fn add_domain(
    &self,
    dom: &str,
    optargs: AddDomainOptArgs
) -> Result<i32, Error>

add the disk(s) from a named libvirt domain

pub fn add_drive(
    &self,
    filename: &str,
    optargs: AddDriveOptArgs
) -> Result<(), Error>

add an image to examine or modify

pub fn add_drive_ro(&self, filename: &str) -> Result<(), Error>

add a drive in snapshot mode (read-only)

pub fn add_drive_ro_with_if(
    &self,
    filename: &str,
    iface: &str
) -> Result<(), Error>

add a drive read-only specifying the QEMU block emulation to use

pub fn add_drive_scratch(
    &self,
    size: i64,
    optargs: AddDriveScratchOptArgs
) -> Result<(), Error>

add a temporary scratch drive

pub fn add_drive_with_if(
    &self,
    filename: &str,
    iface: &str
) -> Result<(), Error>

add a drive specifying the QEMU block emulation to use

pub fn add_libvirt_dom(
    &self,
    dom: *mut c_void,
    optargs: AddLibvirtDomOptArgs
) -> Result<i32, Error>

add the disk(s) from a libvirt domain

pub fn aug_clear(&self, augpath: &str) -> Result<(), Error>

clear Augeas path

pub fn aug_close(&self) -> Result<(), Error>

close the current Augeas handle

pub fn aug_defnode(
    &self,
    name: &str,
    expr: &str,
    val: &str
) -> Result<IntBool, Error>

define an Augeas node

pub fn aug_defvar(&self, name: &str, expr: Option<&str>) -> Result<i32, Error>

define an Augeas variable

pub fn aug_get(&self, augpath: &str) -> Result<String, Error>

look up the value of an Augeas path

pub fn aug_init(&self, root: &str, flags: i32) -> Result<(), Error>

create a new Augeas handle

pub fn aug_insert(
    &self,
    augpath: &str,
    label: &str,
    before: bool
) -> Result<(), Error>

insert a sibling Augeas node

pub fn aug_label(&self, augpath: &str) -> Result<String, Error>

return the label from an Augeas path expression

pub fn aug_load(&self) -> Result<(), Error>

load files into the tree

pub fn aug_ls(&self, augpath: &str) -> Result<Vec<String>, Error>

list Augeas nodes under augpath

pub fn aug_match(&self, augpath: &str) -> Result<Vec<String>, Error>

return Augeas nodes which match augpath

pub fn aug_mv(&self, src: &str, dest: &str) -> Result<(), Error>

move Augeas node

pub fn aug_rm(&self, augpath: &str) -> Result<i32, Error>

remove an Augeas path

pub fn aug_save(&self) -> Result<(), Error>

write all pending Augeas changes to disk

pub fn aug_set(&self, augpath: &str, val: &str) -> Result<(), Error>

set Augeas path to value

pub fn aug_setm(
    &self,
    base: &str,
    sub: Option<&str>,
    val: &str
) -> Result<i32, Error>

set multiple Augeas nodes

pub fn aug_transform(
    &self,
    lens: &str,
    file: &str,
    optargs: AugTransformOptArgs
) -> Result<(), Error>

add/remove an Augeas lens transformation

pub fn available(&self, groups: &[&str]) -> Result<(), Error>

test availability of some parts of the API

pub fn available_all_groups(&self) -> Result<Vec<String>, Error>

return a list of all optional groups

pub fn base64_in(&self, base64file: &str, filename: &str) -> Result<(), Error>

upload base64-encoded data to file

pub fn base64_out(&self, filename: &str, base64file: &str) -> Result<(), Error>

download file and encode as base64

pub fn blkdiscard(&self, device: &str) -> Result<(), Error>

discard all blocks on a device

pub fn blkdiscardzeroes(&self, device: &str) -> Result<bool, Error>

return true if discarded blocks are read as zeroes

pub fn blkid(&self, device: &str) -> Result<HashMap<String, String>, Error>

print block device attributes

pub fn blockdev_flushbufs(&self, device: &str) -> Result<(), Error>

flush device buffers

pub fn blockdev_getbsz(&self, device: &str) -> Result<i32, Error>

get blocksize of block device

pub fn blockdev_getro(&self, device: &str) -> Result<bool, Error>

is block device set to read-only

pub fn blockdev_getsize64(&self, device: &str) -> Result<i64, Error>

get total size of device in bytes

pub fn blockdev_getss(&self, device: &str) -> Result<i32, Error>

get sectorsize of block device

pub fn blockdev_getsz(&self, device: &str) -> Result<i64, Error>

get total size of device in 512-byte sectors

pub fn blockdev_rereadpt(&self, device: &str) -> Result<(), Error>

reread partition table

pub fn blockdev_setbsz(&self, device: &str, blocksize: i32) -> Result<(), Error>

set blocksize of block device

pub fn blockdev_setra(&self, device: &str, sectors: i32) -> Result<(), Error>

set readahead

pub fn blockdev_setro(&self, device: &str) -> Result<(), Error>

set block device to read-only

pub fn blockdev_setrw(&self, device: &str) -> Result<(), Error>

set block device to read-write

pub fn btrfs_balance_cancel(&self, path: &str) -> Result<(), Error>

cancel a running or paused balance

pub fn btrfs_balance_pause(&self, path: &str) -> Result<(), Error>

pause a running balance

pub fn btrfs_balance_resume(&self, path: &str) -> Result<(), Error>

resume a paused balance

pub fn btrfs_balance_status(&self, path: &str) -> Result<BTRFSBalance, Error>

show the status of a running or paused balance

pub fn btrfs_device_add(&self, devices: &[&str], fs: &str) -> Result<(), Error>

add devices to a btrfs filesystem

pub fn btrfs_device_delete(
    &self,
    devices: &[&str],
    fs: &str
) -> Result<(), Error>

remove devices from a btrfs filesystem

pub fn btrfs_filesystem_balance(&self, fs: &str) -> Result<(), Error>

balance a btrfs filesystem

pub fn btrfs_filesystem_defragment(
    &self,
    path: &str,
    optargs: BtrfsFilesystemDefragmentOptArgs
) -> Result<(), Error>

defragment a file or directory

pub fn btrfs_filesystem_resize(
    &self,
    mountpoint: &str,
    optargs: BtrfsFilesystemResizeOptArgs
) -> Result<(), Error>

resize a btrfs filesystem

pub fn btrfs_filesystem_show(&self, device: &str) -> Result<Vec<String>, Error>

list devices for btrfs filesystem

pub fn btrfs_filesystem_sync(&self, fs: &str) -> Result<(), Error>

sync a btrfs filesystem

pub fn btrfs_fsck(
    &self,
    device: &str,
    optargs: BtrfsFsckOptArgs
) -> Result<(), Error>

check a btrfs filesystem

pub fn btrfs_image(
    &self,
    source: &[&str],
    image: &str,
    optargs: BtrfsImageOptArgs
) -> Result<(), Error>

create an image of a btrfs filesystem

pub fn btrfs_qgroup_assign(
    &self,
    src: &str,
    dst: &str,
    path: &str
) -> Result<(), Error>

add a qgroup to a parent qgroup

pub fn btrfs_qgroup_create(
    &self,
    qgroupid: &str,
    subvolume: &str
) -> Result<(), Error>

create a subvolume quota group

pub fn btrfs_qgroup_destroy(
    &self,
    qgroupid: &str,
    subvolume: &str
) -> Result<(), Error>

destroy a subvolume quota group

pub fn btrfs_qgroup_limit(
    &self,
    subvolume: &str,
    size: i64
) -> Result<(), Error>

limit the size of a subvolume

pub fn btrfs_qgroup_remove(
    &self,
    src: &str,
    dst: &str,
    path: &str
) -> Result<(), Error>

remove a qgroup from its parent qgroup

pub fn btrfs_qgroup_show(&self, path: &str) -> Result<Vec<BTRFSQgroup>, Error>

show subvolume quota groups

pub fn btrfs_quota_enable(&self, fs: &str, enable: bool) -> Result<(), Error>

enable or disable subvolume quota support

pub fn btrfs_quota_rescan(&self, fs: &str) -> Result<(), Error>

trash all qgroup numbers and scan the metadata again with the current config

pub fn btrfs_replace(
    &self,
    srcdev: &str,
    targetdev: &str,
    mntpoint: &str
) -> Result<(), Error>

replace a btrfs managed device with another device

pub fn btrfs_rescue_chunk_recover(&self, device: &str) -> Result<(), Error>

recover the chunk tree of btrfs filesystem

pub fn btrfs_rescue_super_recover(&self, device: &str) -> Result<(), Error>

recover bad superblocks from good copies

pub fn btrfs_scrub_cancel(&self, path: &str) -> Result<(), Error>

cancel a running scrub

pub fn btrfs_scrub_resume(&self, path: &str) -> Result<(), Error>

resume a previously canceled or interrupted scrub

pub fn btrfs_scrub_start(&self, path: &str) -> Result<(), Error>

read all data from all disks and verify checksums

pub fn btrfs_scrub_status(&self, path: &str) -> Result<BTRFSScrub, Error>

show status of running or finished scrub

pub fn btrfs_set_seeding(
    &self,
    device: &str,
    seeding: bool
) -> Result<(), Error>

enable or disable the seeding feature of device

pub fn btrfs_subvolume_create(
    &self,
    dest: &str,
    optargs: BtrfsSubvolumeCreateOptArgs
) -> Result<(), Error>

create a btrfs subvolume

pub fn btrfs_subvolume_delete(&self, subvolume: &str) -> Result<(), Error>

delete a btrfs subvolume or snapshot

pub fn btrfs_subvolume_get_default(&self, fs: &str) -> Result<i64, Error>

get the default subvolume or snapshot of a filesystem

pub fn btrfs_subvolume_list(
    &self,
    fs: &str
) -> Result<Vec<BTRFSSubvolume>, Error>

list btrfs snapshots and subvolumes

pub fn btrfs_subvolume_set_default(
    &self,
    id: i64,
    fs: &str
) -> Result<(), Error>

set default btrfs subvolume

pub fn btrfs_subvolume_show(
    &self,
    subvolume: &str
) -> Result<HashMap<String, String>, Error>

return detailed information of the subvolume

pub fn btrfs_subvolume_snapshot(
    &self,
    source: &str,
    dest: &str,
    optargs: BtrfsSubvolumeSnapshotOptArgs
) -> Result<(), Error>

create a btrfs snapshot

pub fn btrfstune_enable_extended_inode_refs(
    &self,
    device: &str
) -> Result<(), Error>

enable extended inode refs

pub fn btrfstune_enable_skinny_metadata_extent_refs(
    &self,
    device: &str
) -> Result<(), Error>

enable skinny metadata extent refs

pub fn btrfstune_seeding(
    &self,
    device: &str,
    seeding: bool
) -> Result<(), Error>

enable or disable seeding of a btrfs device

pub fn c_pointer(&self) -> Result<i64, Error>

return the C pointer to the guestfs_h handle

pub fn canonical_device_name(&self, device: &str) -> Result<String, Error>

return canonical device name

pub fn cap_get_file(&self, path: &str) -> Result<String, Error>

get the Linux capabilities attached to a file

pub fn cap_set_file(&self, path: &str, cap: &str) -> Result<(), Error>

set the Linux capabilities attached to a file

pub fn case_sensitive_path(&self, path: &str) -> Result<String, Error>

return true path on case-insensitive filesystem

pub fn cat(&self, path: &str) -> Result<String, Error>

list the contents of a file

pub fn checksum(&self, csumtype: &str, path: &str) -> Result<String, Error>

compute MD5, SHAx or CRC checksum of file

pub fn checksum_device(
    &self,
    csumtype: &str,
    device: &str
) -> Result<String, Error>

compute MD5, SHAx or CRC checksum of the contents of a device

pub fn checksums_out(
    &self,
    csumtype: &str,
    directory: &str,
    sumsfile: &str
) -> Result<(), Error>

compute MD5, SHAx or CRC checksum of files in a directory

pub fn chmod(&self, mode: i32, path: &str) -> Result<(), Error>

change file mode

pub fn chown(&self, owner: i32, group: i32, path: &str) -> Result<(), Error>

change file owner and group

pub fn clear_backend_setting(&self, name: &str) -> Result<i32, Error>

remove a single per-backend settings string

pub fn command(&self, arguments: &[&str]) -> Result<String, Error>

run a command from the guest filesystem

pub fn command_lines(&self, arguments: &[&str]) -> Result<Vec<String>, Error>

run a command, returning lines

pub fn compress_device_out(
    &self,
    ctype: &str,
    device: &str,
    zdevice: &str,
    optargs: CompressDeviceOutOptArgs
) -> Result<(), Error>

output compressed device

pub fn compress_out(
    &self,
    ctype: &str,
    file: &str,
    zfile: &str,
    optargs: CompressOutOptArgs
) -> Result<(), Error>

output compressed file

pub fn config(&self, hvparam: &str, hvvalue: Option<&str>) -> Result<(), Error>

add hypervisor parameters

pub fn copy_attributes(
    &self,
    src: &str,
    dest: &str,
    optargs: CopyAttributesOptArgs
) -> Result<(), Error>

copy the attributes of a path (file/directory) to another

pub fn copy_device_to_device(
    &self,
    src: &str,
    dest: &str,
    optargs: CopyDeviceToDeviceOptArgs
) -> Result<(), Error>

copy from source device to destination device

pub fn copy_device_to_file(
    &self,
    src: &str,
    dest: &str,
    optargs: CopyDeviceToFileOptArgs
) -> Result<(), Error>

copy from source device to destination file

pub fn copy_file_to_device(
    &self,
    src: &str,
    dest: &str,
    optargs: CopyFileToDeviceOptArgs
) -> Result<(), Error>

copy from source file to destination device

pub fn copy_file_to_file(
    &self,
    src: &str,
    dest: &str,
    optargs: CopyFileToFileOptArgs
) -> Result<(), Error>

copy from source file to destination file

pub fn copy_in(&self, localpath: &str, remotedir: &str) -> Result<(), Error>

copy local files or directories into an image

pub fn copy_out(&self, remotepath: &str, localdir: &str) -> Result<(), Error>

copy remote files or directories out of an image

pub fn copy_size(&self, src: &str, dest: &str, size: i64) -> Result<(), Error>

copy size bytes from source to destination using dd

pub fn cp(&self, src: &str, dest: &str) -> Result<(), Error>

copy a file

pub fn cp_a(&self, src: &str, dest: &str) -> Result<(), Error>

copy a file or directory recursively

pub fn cp_r(&self, src: &str, dest: &str) -> Result<(), Error>

copy a file or directory recursively

pub fn cpio_out(
    &self,
    directory: &str,
    cpiofile: &str,
    optargs: CpioOutOptArgs
) -> Result<(), Error>

pack directory into cpio file

pub fn dd(&self, src: &str, dest: &str) -> Result<(), Error>

copy from source to destination using dd

pub fn debug(&self, subcmd: &str, extraargs: &[&str]) -> Result<String, Error>

debugging and internals

pub fn debug_drives(&self) -> Result<Vec<String>, Error>

debug the drives (internal use only)

pub fn debug_upload(
    &self,
    filename: &str,
    tmpname: &str,
    mode: i32
) -> Result<(), Error>

upload a file to the appliance (internal use only)

pub fn device_index(&self, device: &str) -> Result<i32, Error>

convert device to index

pub fn df(&self) -> Result<String, Error>

report file system disk space usage

pub fn df_h(&self) -> Result<String, Error>

report file system disk space usage (human readable)

pub fn disk_create(
    &self,
    filename: &str,
    format: &str,
    size: i64,
    optargs: DiskCreateOptArgs
) -> Result<(), Error>

create a blank disk image

pub fn disk_format(&self, filename: &str) -> Result<String, Error>

detect the disk format of a disk image

pub fn disk_has_backing_file(&self, filename: &str) -> Result<bool, Error>

return whether disk has a backing file

pub fn disk_virtual_size(&self, filename: &str) -> Result<i64, Error>

return virtual size of a disk

pub fn dmesg(&self) -> Result<String, Error>

return kernel messages

pub fn download(
    &self,
    remotefilename: &str,
    filename: &str
) -> Result<(), Error>

download a file to the local machine

pub fn download_blocks(
    &self,
    device: &str,
    start: i64,
    stop: i64,
    filename: &str,
    optargs: DownloadBlocksOptArgs
) -> Result<(), Error>

download the given data units from the disk

pub fn download_inode(
    &self,
    device: &str,
    inode: i64,
    filename: &str
) -> Result<(), Error>

download a file to the local machine given its inode

pub fn download_offset(
    &self,
    remotefilename: &str,
    filename: &str,
    offset: i64,
    size: i64
) -> Result<(), Error>

download a file to the local machine with offset and size

pub fn drop_caches(&self, whattodrop: i32) -> Result<(), Error>

drop kernel page cache, dentries and inodes

pub fn du(&self, path: &str) -> Result<i64, Error>

estimate file space usage

pub fn e2fsck(&self, device: &str, optargs: E2fsckOptArgs) -> Result<(), Error>

check an ext2/ext3 filesystem

pub fn e2fsck_f(&self, device: &str) -> Result<(), Error>

check an ext2/ext3 filesystem

pub fn echo_daemon(&self, words: &[&str]) -> Result<String, Error>

echo arguments back to the client

pub fn egrep(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn egrepi(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn equal(&self, file1: &str, file2: &str) -> Result<bool, Error>

test if two files have equal contents

pub fn exists(&self, path: &str) -> Result<bool, Error>

test if file or directory exists

pub fn extlinux(&self, directory: &str) -> Result<(), Error>

install the SYSLINUX bootloader on an ext2/3/4 or btrfs filesystem

pub fn f2fs_expand(&self, device: &str) -> Result<(), Error>

expand a f2fs filesystem

pub fn fallocate(&self, path: &str, len: i32) -> Result<(), Error>

preallocate a file in the guest filesystem

pub fn fallocate64(&self, path: &str, len: i64) -> Result<(), Error>

preallocate a file in the guest filesystem

pub fn feature_available(&self, groups: &[&str]) -> Result<bool, Error>

test availability of some parts of the API

pub fn fgrep(&self, pattern: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn fgrepi(&self, pattern: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn file(&self, path: &str) -> Result<String, Error>

determine file type

pub fn file_architecture(&self, filename: &str) -> Result<String, Error>

detect the architecture of a binary file

pub fn filesize(&self, file: &str) -> Result<i64, Error>

return the size of the file in bytes

pub fn filesystem_available(&self, filesystem: &str) -> Result<bool, Error>

check if filesystem is available

pub fn filesystem_walk(&self, device: &str) -> Result<Vec<TSKDirent>, Error>

walk through the filesystem content

pub fn fill(&self, c: i32, len: i32, path: &str) -> Result<(), Error>

fill a file with octets

pub fn fill_dir(&self, dir: &str, nr: i32) -> Result<(), Error>

fill a directory with empty files

pub fn fill_pattern(
    &self,
    pattern: &str,
    len: i32,
    path: &str
) -> Result<(), Error>

fill a file with a repeating pattern of bytes

pub fn find(&self, directory: &str) -> Result<Vec<String>, Error>

find all files and directories

pub fn find0(&self, directory: &str, files: &str) -> Result<(), Error>

find all files and directories, returning NUL-separated list

pub fn find_inode(
    &self,
    device: &str,
    inode: i64
) -> Result<Vec<TSKDirent>, Error>

search the entries associated to the given inode

pub fn findfs_label(&self, label: &str) -> Result<String, Error>

find a filesystem by label

pub fn findfs_uuid(&self, uuid: &str) -> Result<String, Error>

find a filesystem by UUID

pub fn fsck(&self, fstype: &str, device: &str) -> Result<i32, Error>

run the filesystem checker

pub fn fstrim(
    &self,
    mountpoint: &str,
    optargs: FstrimOptArgs
) -> Result<(), Error>

trim free space in a filesystem

pub fn get_append(&self) -> Result<Option<&'static str>, Error>

get the additional kernel options

pub fn get_attach_method(&self) -> Result<String, Error>

get the backend

pub fn get_autosync(&self) -> Result<bool, Error>

get autosync mode

pub fn get_backend(&self) -> Result<String, Error>

get the backend

pub fn get_backend_setting(&self, name: &str) -> Result<String, Error>

get a single per-backend settings string

pub fn get_backend_settings(&self) -> Result<Vec<String>, Error>

get per-backend settings

pub fn get_cachedir(&self) -> Result<String, Error>

get the appliance cache directory

pub fn get_direct(&self) -> Result<bool, Error>

get direct appliance mode flag

pub fn get_e2attrs(&self, file: &str) -> Result<String, Error>

get ext2 file attributes of a file

pub fn get_e2generation(&self, file: &str) -> Result<i64, Error>

get ext2 file generation of a file

pub fn get_e2label(&self, device: &str) -> Result<String, Error>

get the ext2/3/4 filesystem label

pub fn get_e2uuid(&self, device: &str) -> Result<String, Error>

get the ext2/3/4 filesystem UUID

pub fn get_hv(&self) -> Result<String, Error>

get the hypervisor binary

pub fn get_identifier(&self) -> Result<&'static str, Error>

get the handle identifier

pub fn get_libvirt_requested_credential_challenge(
    &self,
    index: i32
) -> Result<String, Error>

challenge of i'th requested credential

pub fn get_libvirt_requested_credential_defresult(
    &self,
    index: i32
) -> Result<String, Error>

default result of i'th requested credential

pub fn get_libvirt_requested_credential_prompt(
    &self,
    index: i32
) -> Result<String, Error>

prompt of i'th requested credential

pub fn get_libvirt_requested_credentials(&self) -> Result<Vec<String>, Error>

get list of credentials requested by libvirt

pub fn get_memsize(&self) -> Result<i32, Error>

get memory allocated to the hypervisor

pub fn get_network(&self) -> Result<bool, Error>

get enable network flag

pub fn get_path(&self) -> Result<&'static str, Error>

get the search path

pub fn get_pgroup(&self) -> Result<bool, Error>

get process group flag

pub fn get_pid(&self) -> Result<i32, Error>

get PID of hypervisor

pub fn get_program(&self) -> Result<&'static str, Error>

get the program name

pub fn get_qemu(&self) -> Result<&'static str, Error>

get the hypervisor binary (usually qemu)

pub fn get_recovery_proc(&self) -> Result<bool, Error>

get recovery process enabled flag

pub fn get_selinux(&self) -> Result<bool, Error>

get SELinux enabled flag

pub fn get_smp(&self) -> Result<i32, Error>

get number of virtual CPUs in appliance

pub fn get_sockdir(&self) -> Result<String, Error>

get the temporary directory for sockets

pub fn get_state(&self) -> Result<i32, Error>

get the current state

pub fn get_tmpdir(&self) -> Result<String, Error>

get the temporary directory

pub fn get_trace(&self) -> Result<bool, Error>

get command trace enabled flag

pub fn get_umask(&self) -> Result<i32, Error>

get the current umask

pub fn get_verbose(&self) -> Result<bool, Error>

get verbose mode

pub fn getcon(&self) -> Result<String, Error>

get SELinux security context

pub fn getxattr(&self, path: &str, name: &str) -> Result<Vec<u8>, Error>

get a single extended attribute

pub fn getxattrs(&self, path: &str) -> Result<Vec<XAttr>, Error>

list extended attributes of a file or directory

pub fn glob_expand(
    &self,
    pattern: &str,
    optargs: GlobExpandOptArgs
) -> Result<Vec<String>, Error>

expand a wildcard path

pub fn grep(
    &self,
    regex: &str,
    path: &str,
    optargs: GrepOptArgs
) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn grepi(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn grub_install(&self, root: &str, device: &str) -> Result<(), Error>

install GRUB 1

pub fn head(&self, path: &str) -> Result<Vec<String>, Error>

return first 10 lines of a file

pub fn head_n(&self, nrlines: i32, path: &str) -> Result<Vec<String>, Error>

return first N lines of a file

pub fn hexdump(&self, path: &str) -> Result<String, Error>

dump a file in hexadecimal

pub fn hivex_close(&self) -> Result<(), Error>

close the current hivex handle

pub fn hivex_commit(&self, filename: Option<&str>) -> Result<(), Error>

commit (write) changes back to the hive

pub fn hivex_node_add_child(
    &self,
    parent: i64,
    name: &str
) -> Result<i64, Error>

add a child node

pub fn hivex_node_children(&self, nodeh: i64) -> Result<Vec<HivexNode>, Error>

return list of nodes which are subkeys of node

pub fn hivex_node_delete_child(&self, nodeh: i64) -> Result<(), Error>

delete a node (recursively)

pub fn hivex_node_get_child(&self, nodeh: i64, name: &str) -> Result<i64, Error>

return the named child of node

pub fn hivex_node_get_value(&self, nodeh: i64, key: &str) -> Result<i64, Error>

return the named value

pub fn hivex_node_name(&self, nodeh: i64) -> Result<String, Error>

return the name of the node

pub fn hivex_node_parent(&self, nodeh: i64) -> Result<i64, Error>

return the parent of node

pub fn hivex_node_set_value(
    &self,
    nodeh: i64,
    key: &str,
    t: i64,
    val: &[u8]
) -> Result<(), Error>

set or replace a single value in a node

pub fn hivex_node_values(&self, nodeh: i64) -> Result<Vec<HivexValue>, Error>

return list of values attached to node

pub fn hivex_open(
    &self,
    filename: &str,
    optargs: HivexOpenOptArgs
) -> Result<(), Error>

open a Windows Registry hive file

pub fn hivex_root(&self) -> Result<i64, Error>

return the root node of the hive

pub fn hivex_value_key(&self, valueh: i64) -> Result<String, Error>

return the key field from the (key, datatype, data) tuple

pub fn hivex_value_string(&self, valueh: i64) -> Result<String, Error>

return the data field as a UTF-8 string

pub fn hivex_value_type(&self, valueh: i64) -> Result<i64, Error>

return the data type from the (key, datatype, data) tuple

pub fn hivex_value_utf8(&self, valueh: i64) -> Result<String, Error>

return the data field as a UTF-8 string

pub fn hivex_value_value(&self, valueh: i64) -> Result<Vec<u8>, Error>

return the data field from the (key, datatype, data) tuple

pub fn initrd_cat(
    &self,
    initrdpath: &str,
    filename: &str
) -> Result<Vec<u8>, Error>

list the contents of a single file in an initrd

pub fn initrd_list(&self, path: &str) -> Result<Vec<String>, Error>

list files in an initrd

pub fn inotify_add_watch(&self, path: &str, mask: i32) -> Result<i64, Error>

add an inotify watch

pub fn inotify_close(&self) -> Result<(), Error>

close the inotify handle

pub fn inotify_files(&self) -> Result<Vec<String>, Error>

return list of watched files that had events

pub fn inotify_init(&self, maxevents: i32) -> Result<(), Error>

create an inotify handle

pub fn inotify_read(&self) -> Result<Vec<INotifyEvent>, Error>

return list of inotify events

pub fn inotify_rm_watch(&self, wd: i32) -> Result<(), Error>

remove an inotify watch

pub fn inspect_get_arch(&self, root: &str) -> Result<String, Error>

get architecture of inspected operating system

pub fn inspect_get_distro(&self, root: &str) -> Result<String, Error>

get distro of inspected operating system

pub fn inspect_get_drive_mappings(
    &self,
    root: &str
) -> Result<HashMap<String, String>, Error>

get drive letter mappings

pub fn inspect_get_filesystems(&self, root: &str) -> Result<Vec<String>, Error>

get filesystems associated with inspected operating system

pub fn inspect_get_format(&self, root: &str) -> Result<String, Error>

get format of inspected operating system

pub fn inspect_get_hostname(&self, root: &str) -> Result<String, Error>

get hostname of the operating system

pub fn inspect_get_icon(
    &self,
    root: &str,
    optargs: InspectGetIconOptArgs
) -> Result<Vec<u8>, Error>

get the icon corresponding to this operating system

pub fn inspect_get_major_version(&self, root: &str) -> Result<i32, Error>

get major version of inspected operating system

pub fn inspect_get_minor_version(&self, root: &str) -> Result<i32, Error>

get minor version of inspected operating system

pub fn inspect_get_mountpoints(
    &self,
    root: &str
) -> Result<HashMap<String, String>, Error>

get mountpoints of inspected operating system

pub fn inspect_get_osinfo(&self, root: &str) -> Result<String, Error>

get a possible osinfo short ID corresponding to this operating system

pub fn inspect_get_package_format(&self, root: &str) -> Result<String, Error>

get package format used by the operating system

pub fn inspect_get_package_management(
    &self,
    root: &str
) -> Result<String, Error>

get package management tool used by the operating system

pub fn inspect_get_product_name(&self, root: &str) -> Result<String, Error>

get product name of inspected operating system

pub fn inspect_get_product_variant(&self, root: &str) -> Result<String, Error>

get product variant of inspected operating system

pub fn inspect_get_roots(&self) -> Result<Vec<String>, Error>

return list of operating systems found by last inspection

pub fn inspect_get_type(&self, root: &str) -> Result<String, Error>

get type of inspected operating system

pub fn inspect_get_windows_current_control_set(
    &self,
    root: &str
) -> Result<String, Error>

get Windows CurrentControlSet of inspected operating system

pub fn inspect_get_windows_software_hive(
    &self,
    root: &str
) -> Result<String, Error>

get the path of the Windows software hive

pub fn inspect_get_windows_system_hive(
    &self,
    root: &str
) -> Result<String, Error>

get the path of the Windows system hive

pub fn inspect_get_windows_systemroot(
    &self,
    root: &str
) -> Result<String, Error>

get Windows systemroot of inspected operating system

pub fn inspect_is_live(&self, root: &str) -> Result<bool, Error>

get live flag for install disk

pub fn inspect_is_multipart(&self, root: &str) -> Result<bool, Error>

get multipart flag for install disk

pub fn inspect_is_netinst(&self, root: &str) -> Result<bool, Error>

get netinst (network installer) flag for install disk

pub fn inspect_list_applications(
    &self,
    root: &str
) -> Result<Vec<Application>, Error>

get list of applications installed in the operating system

pub fn inspect_list_applications2(
    &self,
    root: &str
) -> Result<Vec<Application2>, Error>

get list of applications installed in the operating system

pub fn inspect_os(&self) -> Result<Vec<String>, Error>

inspect disk and return list of operating systems found

pub fn internal_exit(&self) -> Result<(), Error>

cause the daemon to exit (internal use only)

pub fn internal_test(
    &self,
    str: &str,
    optstr: Option<&str>,
    strlist: &[&str],
    b: bool,
    integer: i32,
    integer64: i64,
    filein: &str,
    fileout: &str,
    bufferin: &[u8],
    optargs: InternalTestOptArgs
) -> Result<(), Error>

internal test function - do not use

pub fn internal_test_63_optargs(
    &self,
    optargs: InternalTest63OptargsOptArgs
) -> Result<(), Error>

internal test function - do not use

pub fn internal_test_close_output(&self) -> Result<(), Error>

internal test function - do not use

pub fn internal_test_only_optargs(
    &self,
    optargs: InternalTestOnlyOptargsOptArgs
) -> Result<(), Error>

internal test function - do not use

pub fn internal_test_rbool(&self, val: &str) -> Result<bool, Error>

internal test function - do not use

pub fn internal_test_rboolerr(&self) -> Result<bool, Error>

internal test function - do not use

pub fn internal_test_rbufferout(&self, val: &str) -> Result<Vec<u8>, Error>

internal test function - do not use

pub fn internal_test_rbufferouterr(&self) -> Result<Vec<u8>, Error>

internal test function - do not use

pub fn internal_test_rconstoptstring(
    &self,
    val: &str
) -> Result<Option<&'static str>, Error>

internal test function - do not use

pub fn internal_test_rconstoptstringerr(
    &self
) -> Result<Option<&'static str>, Error>

internal test function - do not use

pub fn internal_test_rconststring(
    &self,
    val: &str
) -> Result<&'static str, Error>

internal test function - do not use

pub fn internal_test_rconststringerr(&self) -> Result<&'static str, Error>

internal test function - do not use

pub fn internal_test_rhashtable(
    &self,
    val: &str
) -> Result<HashMap<String, String>, Error>

internal test function - do not use

pub fn internal_test_rhashtableerr(
    &self
) -> Result<HashMap<String, String>, Error>

internal test function - do not use

pub fn internal_test_rint(&self, val: &str) -> Result<i32, Error>

internal test function - do not use

pub fn internal_test_rint64(&self, val: &str) -> Result<i64, Error>

internal test function - do not use

pub fn internal_test_rint64err(&self) -> Result<i64, Error>

internal test function - do not use

pub fn internal_test_rinterr(&self) -> Result<i32, Error>

internal test function - do not use

pub fn internal_test_rstring(&self, val: &str) -> Result<String, Error>

internal test function - do not use

pub fn internal_test_rstringerr(&self) -> Result<String, Error>

internal test function - do not use

pub fn internal_test_rstringlist(&self, val: &str) -> Result<Vec<String>, Error>

internal test function - do not use

pub fn internal_test_rstringlisterr(&self) -> Result<Vec<String>, Error>

internal test function - do not use

pub fn internal_test_rstruct(&self, val: &str) -> Result<PV, Error>

internal test function - do not use

pub fn internal_test_rstructerr(&self) -> Result<PV, Error>

internal test function - do not use

pub fn internal_test_rstructlist(&self, val: &str) -> Result<Vec<PV>, Error>

internal test function - do not use

pub fn internal_test_rstructlisterr(&self) -> Result<Vec<PV>, Error>

internal test function - do not use

pub fn internal_test_set_output(&self, filename: &str) -> Result<(), Error>

internal test function - do not use

pub fn is_blockdev(
    &self,
    path: &str,
    optargs: IsBlockdevOptArgs
) -> Result<bool, Error>

test if block device

pub fn is_busy(&self) -> Result<bool, Error>

is busy processing a command

pub fn is_chardev(
    &self,
    path: &str,
    optargs: IsChardevOptArgs
) -> Result<bool, Error>

test if character device

pub fn is_config(&self) -> Result<bool, Error>

is in configuration state

pub fn is_dir(&self, path: &str, optargs: IsDirOptArgs) -> Result<bool, Error>

test if a directory

pub fn is_fifo(&self, path: &str, optargs: IsFifoOptArgs) -> Result<bool, Error>

test if FIFO (named pipe)

pub fn is_file(&self, path: &str, optargs: IsFileOptArgs) -> Result<bool, Error>

test if a regular file

pub fn is_launching(&self) -> Result<bool, Error>

is launching subprocess

pub fn is_lv(&self, mountable: &str) -> Result<bool, Error>

test if mountable is a logical volume

pub fn is_ready(&self) -> Result<bool, Error>

is ready to accept commands

pub fn is_socket(
    &self,
    path: &str,
    optargs: IsSocketOptArgs
) -> Result<bool, Error>

test if socket

pub fn is_symlink(&self, path: &str) -> Result<bool, Error>

test if symbolic link

pub fn is_whole_device(&self, device: &str) -> Result<bool, Error>

test if a device is a whole device

pub fn is_zero(&self, path: &str) -> Result<bool, Error>

test if a file contains all zero bytes

pub fn is_zero_device(&self, device: &str) -> Result<bool, Error>

test if a device contains all zero bytes

pub fn isoinfo(&self, isofile: &str) -> Result<ISOInfo, Error>

get ISO information from primary volume descriptor of ISO file

pub fn isoinfo_device(&self, device: &str) -> Result<ISOInfo, Error>

get ISO information from primary volume descriptor of device

pub fn journal_close(&self) -> Result<(), Error>

close the systemd journal

pub fn journal_get(&self) -> Result<Vec<XAttr>, Error>

read the current journal entry

pub fn journal_get_data_threshold(&self) -> Result<i64, Error>

get the data threshold for reading journal entries

pub fn journal_get_realtime_usec(&self) -> Result<i64, Error>

get the timestamp of the current journal entry

pub fn journal_next(&self) -> Result<bool, Error>

move to the next journal entry

pub fn journal_open(&self, directory: &str) -> Result<(), Error>

open the systemd journal

pub fn journal_set_data_threshold(&self, threshold: i64) -> Result<(), Error>

set the data threshold for reading journal entries

pub fn journal_skip(&self, skip: i64) -> Result<i64, Error>

skip forwards or backwards in the journal

pub fn kill_subprocess(&self) -> Result<(), Error>

kill the hypervisor

pub fn launch(&self) -> Result<(), Error>

launch the backend

pub fn lchown(&self, owner: i32, group: i32, path: &str) -> Result<(), Error>

change file owner and group

pub fn ldmtool_create_all(&self) -> Result<(), Error>

scan and create Windows dynamic disk volumes

pub fn ldmtool_diskgroup_disks(
    &self,
    diskgroup: &str
) -> Result<Vec<String>, Error>

return the disks in a Windows dynamic disk group

pub fn ldmtool_diskgroup_name(&self, diskgroup: &str) -> Result<String, Error>

return the name of a Windows dynamic disk group

pub fn ldmtool_diskgroup_volumes(
    &self,
    diskgroup: &str
) -> Result<Vec<String>, Error>

return the volumes in a Windows dynamic disk group

pub fn ldmtool_remove_all(&self) -> Result<(), Error>

remove all Windows dynamic disk volumes

pub fn ldmtool_scan(&self) -> Result<Vec<String>, Error>

scan for Windows dynamic disks

pub fn ldmtool_scan_devices(
    &self,
    devices: &[&str]
) -> Result<Vec<String>, Error>

scan for Windows dynamic disks

pub fn ldmtool_volume_hint(
    &self,
    diskgroup: &str,
    volume: &str
) -> Result<String, Error>

return the hint field of a Windows dynamic disk volume

pub fn ldmtool_volume_partitions(
    &self,
    diskgroup: &str,
    volume: &str
) -> Result<Vec<String>, Error>

return the partitions in a Windows dynamic disk volume

pub fn ldmtool_volume_type(
    &self,
    diskgroup: &str,
    volume: &str
) -> Result<String, Error>

return the type of a Windows dynamic disk volume

pub fn lgetxattr(&self, path: &str, name: &str) -> Result<Vec<u8>, Error>

get a single extended attribute

pub fn lgetxattrs(&self, path: &str) -> Result<Vec<XAttr>, Error>

list extended attributes of a file or directory

pub fn list_9p(&self) -> Result<Vec<String>, Error>

list 9p filesystems

pub fn list_devices(&self) -> Result<Vec<String>, Error>

list the block devices

pub fn list_disk_labels(&self) -> Result<HashMap<String, String>, Error>

mapping of disk labels to devices

pub fn list_dm_devices(&self) -> Result<Vec<String>, Error>

list device mapper devices

pub fn list_filesystems(&self) -> Result<HashMap<String, String>, Error>

list filesystems

pub fn list_ldm_partitions(&self) -> Result<Vec<String>, Error>

list all Windows dynamic disk partitions

pub fn list_ldm_volumes(&self) -> Result<Vec<String>, Error>

list all Windows dynamic disk volumes

pub fn list_md_devices(&self) -> Result<Vec<String>, Error>

list Linux md (RAID) devices

pub fn list_partitions(&self) -> Result<Vec<String>, Error>

list the partitions

pub fn ll(&self, directory: &str) -> Result<String, Error>

list the files in a directory (long format)

pub fn llz(&self, directory: &str) -> Result<String, Error>

list the files in a directory (long format with SELinux contexts)

pub fn ln(&self, target: &str, linkname: &str) -> Result<(), Error>

create a hard link

pub fn ln_f(&self, target: &str, linkname: &str) -> Result<(), Error>

create a hard link

pub fn ln_s(&self, target: &str, linkname: &str) -> Result<(), Error>

create a symbolic link

pub fn ln_sf(&self, target: &str, linkname: &str) -> Result<(), Error>

create a symbolic link

pub fn lremovexattr(&self, xattr: &str, path: &str) -> Result<(), Error>

remove extended attribute of a file or directory

pub fn ls(&self, directory: &str) -> Result<Vec<String>, Error>

list the files in a directory

pub fn ls0(&self, dir: &str, filenames: &str) -> Result<(), Error>

get list of files in a directory

pub fn lsetxattr(
    &self,
    xattr: &str,
    val: &str,
    vallen: i32,
    path: &str
) -> Result<(), Error>

set extended attribute of a file or directory

pub fn lstat(&self, path: &str) -> Result<Stat, Error>

get file information for a symbolic link

pub fn lstatlist(&self, path: &str, names: &[&str]) -> Result<Vec<Stat>, Error>

lstat on multiple files

pub fn lstatns(&self, path: &str) -> Result<StatNS, Error>

get file information for a symbolic link

pub fn lstatnslist(
    &self,
    path: &str,
    names: &[&str]
) -> Result<Vec<StatNS>, Error>

lstat on multiple files

pub fn luks_add_key(
    &self,
    device: &str,
    key: &str,
    newkey: &str,
    keyslot: i32
) -> Result<(), Error>

add a key on a LUKS encrypted device

pub fn luks_close(&self, device: &str) -> Result<(), Error>

close a LUKS device

pub fn luks_format(
    &self,
    device: &str,
    key: &str,
    keyslot: i32
) -> Result<(), Error>

format a block device as a LUKS encrypted device

pub fn luks_format_cipher(
    &self,
    device: &str,
    key: &str,
    keyslot: i32,
    cipher: &str
) -> Result<(), Error>

format a block device as a LUKS encrypted device

pub fn luks_kill_slot(
    &self,
    device: &str,
    key: &str,
    keyslot: i32
) -> Result<(), Error>

remove a key from a LUKS encrypted device

pub fn luks_open(
    &self,
    device: &str,
    key: &str,
    mapname: &str
) -> Result<(), Error>

open a LUKS-encrypted block device

pub fn luks_open_ro(
    &self,
    device: &str,
    key: &str,
    mapname: &str
) -> Result<(), Error>

open a LUKS-encrypted block device read-only

pub fn lvcreate(
    &self,
    logvol: &str,
    volgroup: &str,
    mbytes: i32
) -> Result<(), Error>

create an LVM logical volume

pub fn lvcreate_free(
    &self,
    logvol: &str,
    volgroup: &str,
    percent: i32
) -> Result<(), Error>

create an LVM logical volume in % remaining free space

pub fn lvm_canonical_lv_name(&self, lvname: &str) -> Result<String, Error>

get canonical name of an LV

pub fn lvm_clear_filter(&self) -> Result<(), Error>

clear LVM device filter

pub fn lvm_remove_all(&self) -> Result<(), Error>

remove all LVM LVs, VGs and PVs

pub fn lvm_scan(&self, activate: bool) -> Result<(), Error>

scan for LVM physical volumes, volume groups and logical volumes

pub fn lvm_set_filter(&self, devices: &[&str]) -> Result<(), Error>

set LVM device filter

pub fn lvremove(&self, device: &str) -> Result<(), Error>

remove an LVM logical volume

pub fn lvrename(&self, logvol: &str, newlogvol: &str) -> Result<(), Error>

rename an LVM logical volume

pub fn lvresize(&self, device: &str, mbytes: i32) -> Result<(), Error>

resize an LVM logical volume

pub fn lvresize_free(&self, lv: &str, percent: i32) -> Result<(), Error>

expand an LV to fill free space

pub fn lvs(&self) -> Result<Vec<String>, Error>

list the LVM logical volumes (LVs)

pub fn lvs_full(&self) -> Result<Vec<LV>, Error>

list the LVM logical volumes (LVs)

pub fn lvuuid(&self, device: &str) -> Result<String, Error>

get the UUID of a logical volume

pub fn lxattrlist(
    &self,
    path: &str,
    names: &[&str]
) -> Result<Vec<XAttr>, Error>

lgetxattr on multiple files

pub fn max_disks(&self) -> Result<i32, Error>

maximum number of disks that may be added

pub fn md_create(
    &self,
    name: &str,
    devices: &[&str],
    optargs: MdCreateOptArgs
) -> Result<(), Error>

create a Linux md (RAID) device

pub fn md_detail(&self, md: &str) -> Result<HashMap<String, String>, Error>

obtain metadata for an MD device

pub fn md_stat(&self, md: &str) -> Result<Vec<MDStat>, Error>

get underlying devices from an MD device

pub fn md_stop(&self, md: &str) -> Result<(), Error>

stop a Linux md (RAID) device

pub fn mkdir(&self, path: &str) -> Result<(), Error>

create a directory

pub fn mkdir_mode(&self, path: &str, mode: i32) -> Result<(), Error>

create a directory with a particular mode

pub fn mkdir_p(&self, path: &str) -> Result<(), Error>

create a directory and parents

pub fn mkdtemp(&self, tmpl: &str) -> Result<String, Error>

create a temporary directory

pub fn mke2fs(&self, device: &str, optargs: Mke2fsOptArgs) -> Result<(), Error>

create an ext2/ext3/ext4 filesystem on device

pub fn mke2fs_J(
    &self,
    fstype: &str,
    blocksize: i32,
    device: &str,
    journal: &str
) -> Result<(), Error>

make ext2/3/4 filesystem with external journal

pub fn mke2fs_JL(
    &self,
    fstype: &str,
    blocksize: i32,
    device: &str,
    label: &str
) -> Result<(), Error>

make ext2/3/4 filesystem with external journal

pub fn mke2fs_JU(
    &self,
    fstype: &str,
    blocksize: i32,
    device: &str,
    uuid: &str
) -> Result<(), Error>

make ext2/3/4 filesystem with external journal

pub fn mke2journal(&self, blocksize: i32, device: &str) -> Result<(), Error>

make ext2/3/4 external journal

pub fn mke2journal_L(
    &self,
    blocksize: i32,
    label: &str,
    device: &str
) -> Result<(), Error>

make ext2/3/4 external journal with label

pub fn mke2journal_U(
    &self,
    blocksize: i32,
    uuid: &str,
    device: &str
) -> Result<(), Error>

make ext2/3/4 external journal with UUID

pub fn mkfifo(&self, mode: i32, path: &str) -> Result<(), Error>

make FIFO (named pipe)

pub fn mkfs(
    &self,
    fstype: &str,
    device: &str,
    optargs: MkfsOptArgs
) -> Result<(), Error>

make a filesystem

pub fn mkfs_b(
    &self,
    fstype: &str,
    blocksize: i32,
    device: &str
) -> Result<(), Error>

make a filesystem with block size

pub fn mkfs_btrfs(
    &self,
    devices: &[&str],
    optargs: MkfsBtrfsOptArgs
) -> Result<(), Error>

create a btrfs filesystem

pub fn mklost_and_found(&self, mountpoint: &str) -> Result<(), Error>

make lost+found directory on an ext2/3/4 filesystem

pub fn mkmountpoint(&self, exemptpath: &str) -> Result<(), Error>

create a mountpoint

pub fn mknod(
    &self,
    mode: i32,
    devmajor: i32,
    devminor: i32,
    path: &str
) -> Result<(), Error>

make block, character or FIFO devices

pub fn mknod_b(
    &self,
    mode: i32,
    devmajor: i32,
    devminor: i32,
    path: &str
) -> Result<(), Error>

make block device node

pub fn mknod_c(
    &self,
    mode: i32,
    devmajor: i32,
    devminor: i32,
    path: &str
) -> Result<(), Error>

make char device node

pub fn mksquashfs(
    &self,
    path: &str,
    filename: &str,
    optargs: MksquashfsOptArgs
) -> Result<(), Error>

create a squashfs filesystem

pub fn mkswap(&self, device: &str, optargs: MkswapOptArgs) -> Result<(), Error>

create a swap partition

pub fn mkswap_L(&self, label: &str, device: &str) -> Result<(), Error>

create a swap partition with a label

pub fn mkswap_U(&self, uuid: &str, device: &str) -> Result<(), Error>

create a swap partition with an explicit UUID

pub fn mkswap_file(&self, path: &str) -> Result<(), Error>

create a swap file

pub fn mktemp(
    &self,
    tmpl: &str,
    optargs: MktempOptArgs
) -> Result<String, Error>

create a temporary file

pub fn modprobe(&self, modulename: &str) -> Result<(), Error>

load a kernel module

pub fn mount(&self, mountable: &str, mountpoint: &str) -> Result<(), Error>

mount a guest disk at a position in the filesystem

pub fn mount_9p(
    &self,
    mounttag: &str,
    mountpoint: &str,
    optargs: Mount9pOptArgs
) -> Result<(), Error>

mount 9p filesystem

pub fn mount_local(
    &self,
    localmountpoint: &str,
    optargs: MountLocalOptArgs
) -> Result<(), Error>

mount on the local filesystem

pub fn mount_local_run(&self) -> Result<(), Error>

run main loop of mount on the local filesystem

pub fn mount_loop(&self, file: &str, mountpoint: &str) -> Result<(), Error>

mount a file using the loop device

pub fn mount_options(
    &self,
    options: &str,
    mountable: &str,
    mountpoint: &str
) -> Result<(), Error>

mount a guest disk with mount options

pub fn mount_ro(&self, mountable: &str, mountpoint: &str) -> Result<(), Error>

mount a guest disk, read-only

pub fn mount_vfs(
    &self,
    options: &str,
    vfstype: &str,
    mountable: &str,
    mountpoint: &str
) -> Result<(), Error>

mount a guest disk with mount options and vfstype

pub fn mountable_device(&self, mountable: &str) -> Result<String, Error>

extract the device part of a mountable

pub fn mountable_subvolume(&self, mountable: &str) -> Result<String, Error>

extract the subvolume part of a mountable

pub fn mountpoints(&self) -> Result<HashMap<String, String>, Error>

show mountpoints

pub fn mounts(&self) -> Result<Vec<String>, Error>

show mounted filesystems

pub fn mv(&self, src: &str, dest: &str) -> Result<(), Error>

move a file

pub fn nr_devices(&self) -> Result<i32, Error>

return number of whole block devices (disks) added

pub fn ntfs_3g_probe(&self, rw: bool, device: &str) -> Result<i32, Error>

probe NTFS volume

pub fn ntfscat_i(
    &self,
    device: &str,
    inode: i64,
    filename: &str
) -> Result<(), Error>

download a file to the local machine given its inode

pub fn ntfsclone_in(&self, backupfile: &str, device: &str) -> Result<(), Error>

restore NTFS from backup file

pub fn ntfsclone_out(
    &self,
    device: &str,
    backupfile: &str,
    optargs: NtfscloneOutOptArgs
) -> Result<(), Error>

save NTFS to backup file

pub fn ntfsfix(
    &self,
    device: &str,
    optargs: NtfsfixOptArgs
) -> Result<(), Error>

fix common errors and force Windows to check NTFS

pub fn ntfsresize(
    &self,
    device: &str,
    optargs: NtfsresizeOptArgs
) -> Result<(), Error>

resize an NTFS filesystem

pub fn ntfsresize_size(&self, device: &str, size: i64) -> Result<(), Error>

resize an NTFS filesystem (with size)

pub fn parse_environment(&self) -> Result<(), Error>

parse the environment and set handle flags accordingly

pub fn parse_environment_list(&self, environment: &[&str]) -> Result<(), Error>

parse the environment and set handle flags accordingly

pub fn part_add(
    &self,
    device: &str,
    prlogex: &str,
    startsect: i64,
    endsect: i64
) -> Result<(), Error>

add a partition to the device

pub fn part_del(&self, device: &str, partnum: i32) -> Result<(), Error>

delete a partition

pub fn part_disk(&self, device: &str, parttype: &str) -> Result<(), Error>

partition whole disk with a single primary partition

pub fn part_expand_gpt(&self, device: &str) -> Result<(), Error>

move backup GPT header to the end of the disk

pub fn part_get_bootable(
    &self,
    device: &str,
    partnum: i32
) -> Result<bool, Error>

return true if a partition is bootable

pub fn part_get_disk_guid(&self, device: &str) -> Result<String, Error>

get the GUID of a GPT-partitioned disk

pub fn part_get_gpt_attributes(
    &self,
    device: &str,
    partnum: i32
) -> Result<i64, Error>

get the attribute flags of a GPT partition

pub fn part_get_gpt_guid(
    &self,
    device: &str,
    partnum: i32
) -> Result<String, Error>

get the GUID of a GPT partition

pub fn part_get_gpt_type(
    &self,
    device: &str,
    partnum: i32
) -> Result<String, Error>

get the type GUID of a GPT partition

pub fn part_get_mbr_id(&self, device: &str, partnum: i32) -> Result<i32, Error>

get the MBR type byte (ID byte) from a partition

pub fn part_get_mbr_part_type(
    &self,
    device: &str,
    partnum: i32
) -> Result<String, Error>

get the MBR partition type

pub fn part_get_name(&self, device: &str, partnum: i32) -> Result<String, Error>

get partition name

pub fn part_get_parttype(&self, device: &str) -> Result<String, Error>

get the partition table type

pub fn part_init(&self, device: &str, parttype: &str) -> Result<(), Error>

create an empty partition table

pub fn part_list(&self, device: &str) -> Result<Vec<Partition>, Error>

list partitions on a device

pub fn part_resize(
    &self,
    device: &str,
    partnum: i32,
    endsect: i64
) -> Result<(), Error>

resize a partition

pub fn part_set_bootable(
    &self,
    device: &str,
    partnum: i32,
    bootable: bool
) -> Result<(), Error>

make a partition bootable

pub fn part_set_disk_guid(&self, device: &str, guid: &str) -> Result<(), Error>

set the GUID of a GPT-partitioned disk

pub fn part_set_disk_guid_random(&self, device: &str) -> Result<(), Error>

set the GUID of a GPT-partitioned disk to random value

pub fn part_set_gpt_attributes(
    &self,
    device: &str,
    partnum: i32,
    attributes: i64
) -> Result<(), Error>

set the attribute flags of a GPT partition

pub fn part_set_gpt_guid(
    &self,
    device: &str,
    partnum: i32,
    guid: &str
) -> Result<(), Error>

set the GUID of a GPT partition

pub fn part_set_gpt_type(
    &self,
    device: &str,
    partnum: i32,
    guid: &str
) -> Result<(), Error>

set the type GUID of a GPT partition

pub fn part_set_mbr_id(
    &self,
    device: &str,
    partnum: i32,
    idbyte: i32
) -> Result<(), Error>

set the MBR type byte (ID byte) of a partition

pub fn part_set_name(
    &self,
    device: &str,
    partnum: i32,
    name: &str
) -> Result<(), Error>

set partition name

pub fn part_to_dev(&self, partition: &str) -> Result<String, Error>

convert partition name to device name

pub fn part_to_partnum(&self, partition: &str) -> Result<i32, Error>

convert partition name to partition number

pub fn ping_daemon(&self) -> Result<(), Error>

ping the guest daemon

pub fn pread(
    &self,
    path: &str,
    count: i32,
    offset: i64
) -> Result<Vec<u8>, Error>

read part of a file

pub fn pread_device(
    &self,
    device: &str,
    count: i32,
    offset: i64
) -> Result<Vec<u8>, Error>

read part of a device

pub fn pvchange_uuid(&self, device: &str) -> Result<(), Error>

generate a new random UUID for a physical volume

pub fn pvchange_uuid_all(&self) -> Result<(), Error>

generate new random UUIDs for all physical volumes

pub fn pvcreate(&self, device: &str) -> Result<(), Error>

create an LVM physical volume

pub fn pvremove(&self, device: &str) -> Result<(), Error>

remove an LVM physical volume

pub fn pvresize(&self, device: &str) -> Result<(), Error>

resize an LVM physical volume

pub fn pvresize_size(&self, device: &str, size: i64) -> Result<(), Error>

resize an LVM physical volume (with size)

pub fn pvs(&self) -> Result<Vec<String>, Error>

list the LVM physical volumes (PVs)

pub fn pvs_full(&self) -> Result<Vec<PV>, Error>

list the LVM physical volumes (PVs)

pub fn pvuuid(&self, device: &str) -> Result<String, Error>

get the UUID of a physical volume

pub fn pwrite(
    &self,
    path: &str,
    content: &[u8],
    offset: i64
) -> Result<i32, Error>

write to part of a file

pub fn pwrite_device(
    &self,
    device: &str,
    content: &[u8],
    offset: i64
) -> Result<i32, Error>

write to part of a device

pub fn read_file(&self, path: &str) -> Result<Vec<u8>, Error>

read a file

pub fn read_lines(&self, path: &str) -> Result<Vec<String>, Error>

read file as lines

pub fn readdir(&self, dir: &str) -> Result<Vec<Dirent>, Error>

read directories entries

pub fn readlink(&self, path: &str) -> Result<String, Error>

read the target of a symbolic link

pub fn readlinklist(
    &self,
    path: &str,
    names: &[&str]
) -> Result<Vec<String>, Error>

readlink on multiple files

pub fn realpath(&self, path: &str) -> Result<String, Error>

canonicalized absolute pathname

pub fn remount(
    &self,
    mountpoint: &str,
    optargs: RemountOptArgs
) -> Result<(), Error>

remount a filesystem with different options

pub fn remove_drive(&self, label: &str) -> Result<(), Error>

remove a disk image

pub fn removexattr(&self, xattr: &str, path: &str) -> Result<(), Error>

remove extended attribute of a file or directory

pub fn rename(&self, oldpath: &str, newpath: &str) -> Result<(), Error>

rename a file on the same filesystem

pub fn resize2fs(&self, device: &str) -> Result<(), Error>

resize an ext2, ext3 or ext4 filesystem

pub fn resize2fs_M(&self, device: &str) -> Result<(), Error>

resize an ext2, ext3 or ext4 filesystem to the minimum size

pub fn resize2fs_size(&self, device: &str, size: i64) -> Result<(), Error>

resize an ext2, ext3 or ext4 filesystem (with size)

pub fn rm(&self, path: &str) -> Result<(), Error>

remove a file

pub fn rm_f(&self, path: &str) -> Result<(), Error>

remove a file ignoring errors

pub fn rm_rf(&self, path: &str) -> Result<(), Error>

remove a file or directory recursively

pub fn rmdir(&self, path: &str) -> Result<(), Error>

remove a directory

pub fn rmmountpoint(&self, exemptpath: &str) -> Result<(), Error>

remove a mountpoint

pub fn rsync(
    &self,
    src: &str,
    dest: &str,
    optargs: RsyncOptArgs
) -> Result<(), Error>

synchronize the contents of two directories

pub fn rsync_in(
    &self,
    remote: &str,
    dest: &str,
    optargs: RsyncInOptArgs
) -> Result<(), Error>

synchronize host or remote filesystem with filesystem

pub fn rsync_out(
    &self,
    src: &str,
    remote: &str,
    optargs: RsyncOutOptArgs
) -> Result<(), Error>

synchronize filesystem with host or remote filesystem

pub fn scrub_device(&self, device: &str) -> Result<(), Error>

scrub (securely wipe) a device

pub fn scrub_file(&self, file: &str) -> Result<(), Error>

scrub (securely wipe) a file

pub fn scrub_freespace(&self, dir: &str) -> Result<(), Error>

scrub (securely wipe) free space

pub fn selinux_relabel(
    &self,
    specfile: &str,
    path: &str,
    optargs: SelinuxRelabelOptArgs
) -> Result<(), Error>

relabel parts of the filesystem

pub fn set_append(&self, append: Option<&str>) -> Result<(), Error>

add options to kernel command line

pub fn set_attach_method(&self, backend: &str) -> Result<(), Error>

set the backend

pub fn set_autosync(&self, autosync: bool) -> Result<(), Error>

set autosync mode

pub fn set_backend(&self, backend: &str) -> Result<(), Error>

set the backend

pub fn set_backend_setting(&self, name: &str, val: &str) -> Result<(), Error>

set a single per-backend settings string

pub fn set_backend_settings(&self, settings: &[&str]) -> Result<(), Error>

replace per-backend settings strings

pub fn set_cachedir(&self, cachedir: Option<&str>) -> Result<(), Error>

set the appliance cache directory

pub fn set_direct(&self, direct: bool) -> Result<(), Error>

enable or disable direct appliance mode

pub fn set_e2attrs(
    &self,
    file: &str,
    attrs: &str,
    optargs: SetE2attrsOptArgs
) -> Result<(), Error>

set ext2 file attributes of a file

pub fn set_e2generation(&self, file: &str, generation: i64) -> Result<(), Error>

set ext2 file generation of a file

pub fn set_e2label(&self, device: &str, label: &str) -> Result<(), Error>

set the ext2/3/4 filesystem label

pub fn set_e2uuid(&self, device: &str, uuid: &str) -> Result<(), Error>

set the ext2/3/4 filesystem UUID

pub fn set_hv(&self, hv: &str) -> Result<(), Error>

set the hypervisor binary

pub fn set_identifier(&self, identifier: &str) -> Result<(), Error>

set the handle identifier

pub fn set_label(&self, mountable: &str, label: &str) -> Result<(), Error>

set filesystem label

pub fn set_libvirt_requested_credential(
    &self,
    index: i32,
    cred: &[u8]
) -> Result<(), Error>

pass requested credential back to libvirt

pub fn set_libvirt_supported_credentials(
    &self,
    creds: &[&str]
) -> Result<(), Error>

set libvirt credentials supported by calling program

pub fn set_memsize(&self, memsize: i32) -> Result<(), Error>

set memory allocated to the hypervisor

pub fn set_network(&self, network: bool) -> Result<(), Error>

set enable network flag

pub fn set_path(&self, searchpath: Option<&str>) -> Result<(), Error>

set the search path

pub fn set_pgroup(&self, pgroup: bool) -> Result<(), Error>

set process group flag

pub fn set_program(&self, program: &str) -> Result<(), Error>

set the program name

pub fn set_qemu(&self, hv: Option<&str>) -> Result<(), Error>

set the hypervisor binary (usually qemu)

pub fn set_recovery_proc(&self, recoveryproc: bool) -> Result<(), Error>

enable or disable the recovery process

pub fn set_selinux(&self, selinux: bool) -> Result<(), Error>

set SELinux enabled or disabled at appliance boot

pub fn set_smp(&self, smp: i32) -> Result<(), Error>

set number of virtual CPUs in appliance

pub fn set_tmpdir(&self, tmpdir: Option<&str>) -> Result<(), Error>

set the temporary directory

pub fn set_trace(&self, trace: bool) -> Result<(), Error>

enable or disable command traces

pub fn set_uuid(&self, device: &str, uuid: &str) -> Result<(), Error>

set the filesystem UUID

pub fn set_uuid_random(&self, device: &str) -> Result<(), Error>

set a random UUID for the filesystem

pub fn set_verbose(&self, verbose: bool) -> Result<(), Error>

set verbose mode

pub fn setcon(&self, context: &str) -> Result<(), Error>

set SELinux security context

pub fn setxattr(
    &self,
    xattr: &str,
    val: &str,
    vallen: i32,
    path: &str
) -> Result<(), Error>

set extended attribute of a file or directory

pub fn sfdisk(
    &self,
    device: &str,
    cyls: i32,
    heads: i32,
    sectors: i32,
    lines: &[&str]
) -> Result<(), Error>

create partitions on a block device

pub fn sfdiskM(&self, device: &str, lines: &[&str]) -> Result<(), Error>

create partitions on a block device

pub fn sfdisk_N(
    &self,
    device: &str,
    partnum: i32,
    cyls: i32,
    heads: i32,
    sectors: i32,
    line: &str
) -> Result<(), Error>

modify a single partition on a block device

pub fn sfdisk_disk_geometry(&self, device: &str) -> Result<String, Error>

display the disk geometry from the partition table

pub fn sfdisk_kernel_geometry(&self, device: &str) -> Result<String, Error>

display the kernel geometry

pub fn sfdisk_l(&self, device: &str) -> Result<String, Error>

display the partition table

pub fn sh(&self, command: &str) -> Result<String, Error>

run a command via the shell

pub fn sh_lines(&self, command: &str) -> Result<Vec<String>, Error>

run a command via the shell returning lines

pub fn shutdown(&self) -> Result<(), Error>

shutdown the hypervisor

pub fn sleep(&self, secs: i32) -> Result<(), Error>

sleep for some seconds

pub fn stat(&self, path: &str) -> Result<Stat, Error>

get file information

pub fn statns(&self, path: &str) -> Result<StatNS, Error>

get file information

pub fn statvfs(&self, path: &str) -> Result<StatVFS, Error>

get file system statistics

pub fn strings(&self, path: &str) -> Result<Vec<String>, Error>

print the printable strings in a file

pub fn strings_e(
    &self,
    encoding: &str,
    path: &str
) -> Result<Vec<String>, Error>

print the printable strings in a file

pub fn swapoff_device(&self, device: &str) -> Result<(), Error>

disable swap on device

pub fn swapoff_file(&self, file: &str) -> Result<(), Error>

disable swap on file

pub fn swapoff_label(&self, label: &str) -> Result<(), Error>

disable swap on labeled swap partition

pub fn swapoff_uuid(&self, uuid: &str) -> Result<(), Error>

disable swap on swap partition by UUID

pub fn swapon_device(&self, device: &str) -> Result<(), Error>

enable swap on device

pub fn swapon_file(&self, file: &str) -> Result<(), Error>

enable swap on file

pub fn swapon_label(&self, label: &str) -> Result<(), Error>

enable swap on labeled swap partition

pub fn swapon_uuid(&self, uuid: &str) -> Result<(), Error>

enable swap on swap partition by UUID

pub fn sync(&self) -> Result<(), Error>

sync disks, writes are flushed through to the disk image

pub fn syslinux(
    &self,
    device: &str,
    optargs: SyslinuxOptArgs
) -> Result<(), Error>

install the SYSLINUX bootloader

pub fn tail(&self, path: &str) -> Result<Vec<String>, Error>

return last 10 lines of a file

pub fn tail_n(&self, nrlines: i32, path: &str) -> Result<Vec<String>, Error>

return last N lines of a file

pub fn tar_in(
    &self,
    tarfile: &str,
    directory: &str,
    optargs: TarInOptArgs
) -> Result<(), Error>

unpack tarfile to directory

pub fn tar_out(
    &self,
    directory: &str,
    tarfile: &str,
    optargs: TarOutOptArgs
) -> Result<(), Error>

pack directory into tarfile

pub fn tgz_in(&self, tarball: &str, directory: &str) -> Result<(), Error>

unpack compressed tarball to directory

pub fn tgz_out(&self, directory: &str, tarball: &str) -> Result<(), Error>

pack directory into compressed tarball

pub fn touch(&self, path: &str) -> Result<(), Error>

update file timestamps or create a new file

pub fn truncate(&self, path: &str) -> Result<(), Error>

truncate a file to zero size

pub fn truncate_size(&self, path: &str, size: i64) -> Result<(), Error>

truncate a file to a particular size

pub fn tune2fs(
    &self,
    device: &str,
    optargs: Tune2fsOptArgs
) -> Result<(), Error>

adjust ext2/ext3/ext4 filesystem parameters

pub fn tune2fs_l(&self, device: &str) -> Result<HashMap<String, String>, Error>

get ext2/ext3/ext4 superblock details

pub fn txz_in(&self, tarball: &str, directory: &str) -> Result<(), Error>

unpack compressed tarball to directory

pub fn txz_out(&self, directory: &str, tarball: &str) -> Result<(), Error>

pack directory into compressed tarball

pub fn umask(&self, mask: i32) -> Result<i32, Error>

set file mode creation mask (umask)

pub fn umount(
    &self,
    pathordevice: &str,
    optargs: UmountOptArgs
) -> Result<(), Error>

unmount a filesystem

pub fn umount_all(&self) -> Result<(), Error>

unmount all filesystems

pub fn umount_local(&self, optargs: UmountLocalOptArgs) -> Result<(), Error>

unmount a locally mounted filesystem

pub fn upload(&self, filename: &str, remotefilename: &str) -> Result<(), Error>

upload a file from the local machine

pub fn upload_offset(
    &self,
    filename: &str,
    remotefilename: &str,
    offset: i64
) -> Result<(), Error>

upload a file from the local machine with offset

pub fn user_cancel(&self) -> Result<(), Error>

cancel the current upload or download operation

pub fn utimens(
    &self,
    path: &str,
    atsecs: i64,
    atnsecs: i64,
    mtsecs: i64,
    mtnsecs: i64
) -> Result<(), Error>

set timestamp of a file with nanosecond precision

pub fn utsname(&self) -> Result<UTSName, Error>

appliance kernel version

pub fn version(&self) -> Result<Version, Error>

get the library version number

pub fn vfs_label(&self, mountable: &str) -> Result<String, Error>

get the filesystem label

pub fn vfs_minimum_size(&self, mountable: &str) -> Result<i64, Error>

get minimum filesystem size

pub fn vfs_type(&self, mountable: &str) -> Result<String, Error>

get the Linux VFS type corresponding to a mounted device

pub fn vfs_uuid(&self, mountable: &str) -> Result<String, Error>

get the filesystem UUID

pub fn vg_activate(
    &self,
    activate: bool,
    volgroups: &[&str]
) -> Result<(), Error>

activate or deactivate some volume groups

pub fn vg_activate_all(&self, activate: bool) -> Result<(), Error>

activate or deactivate all volume groups

pub fn vgchange_uuid(&self, vg: &str) -> Result<(), Error>

generate a new random UUID for a volume group

pub fn vgchange_uuid_all(&self) -> Result<(), Error>

generate new random UUIDs for all volume groups

pub fn vgcreate(&self, volgroup: &str, physvols: &[&str]) -> Result<(), Error>

create an LVM volume group

pub fn vglvuuids(&self, vgname: &str) -> Result<Vec<String>, Error>

get the LV UUIDs of all LVs in the volume group

pub fn vgmeta(&self, vgname: &str) -> Result<Vec<u8>, Error>

get volume group metadata

pub fn vgpvuuids(&self, vgname: &str) -> Result<Vec<String>, Error>

get the PV UUIDs containing the volume group

pub fn vgremove(&self, vgname: &str) -> Result<(), Error>

remove an LVM volume group

pub fn vgrename(&self, volgroup: &str, newvolgroup: &str) -> Result<(), Error>

rename an LVM volume group

pub fn vgs(&self) -> Result<Vec<String>, Error>

list the LVM volume groups (VGs)

pub fn vgs_full(&self) -> Result<Vec<VG>, Error>

list the LVM volume groups (VGs)

pub fn vgscan(&self) -> Result<(), Error>

rescan for LVM physical volumes, volume groups and logical volumes

pub fn vguuid(&self, vgname: &str) -> Result<String, Error>

get the UUID of a volume group

pub fn wait_ready(&self) -> Result<(), Error>

wait until the hypervisor launches (no op)

pub fn wc_c(&self, path: &str) -> Result<i32, Error>

count characters in a file

pub fn wc_l(&self, path: &str) -> Result<i32, Error>

count lines in a file

pub fn wc_w(&self, path: &str) -> Result<i32, Error>

count words in a file

pub fn wipefs(&self, device: &str) -> Result<(), Error>

wipe a filesystem signature from a device

pub fn write(&self, path: &str, content: &[u8]) -> Result<(), Error>

create a new file

pub fn write_append(&self, path: &str, content: &[u8]) -> Result<(), Error>

append content to end of file

pub fn write_file(
    &self,
    path: &str,
    content: &str,
    size: i32
) -> Result<(), Error>

create a file

pub fn xfs_admin(
    &self,
    device: &str,
    optargs: XfsAdminOptArgs
) -> Result<(), Error>

change parameters of an XFS filesystem

pub fn xfs_growfs(
    &self,
    path: &str,
    optargs: XfsGrowfsOptArgs
) -> Result<(), Error>

expand an existing XFS filesystem

pub fn xfs_info(&self, pathordevice: &str) -> Result<XFSInfo, Error>

get geometry of XFS filesystem

pub fn xfs_repair(
    &self,
    device: &str,
    optargs: XfsRepairOptArgs
) -> Result<i32, Error>

repair an XFS filesystem

pub fn yara_destroy(&self) -> Result<(), Error>

destroy previously loaded yara rules

pub fn yara_load(&self, filename: &str) -> Result<(), Error>

load yara rules within libguestfs

pub fn yara_scan(&self, path: &str) -> Result<Vec<YaraDetection>, Error>

scan a file with the loaded yara rules

pub fn zegrep(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn zegrepi(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn zero(&self, device: &str) -> Result<(), Error>

write zeroes to the device

pub fn zero_device(&self, device: &str) -> Result<(), Error>

write zeroes to an entire device

pub fn zero_free_space(&self, directory: &str) -> Result<(), Error>

zero free space in a filesystem

pub fn zerofree(&self, device: &str) -> Result<(), Error>

zero unused inodes and disk blocks on ext2/3 filesystem

pub fn zfgrep(&self, pattern: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn zfgrepi(&self, pattern: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn zfile(&self, meth: &str, path: &str) -> Result<String, Error>

determine file type inside a compressed file

pub fn zgrep(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

pub fn zgrepi(&self, regex: &str, path: &str) -> Result<Vec<String>, Error>

return lines matching a pattern

Trait Implementations

impl Drop for Handle

fn drop(&mut self)

Executes the destructor for this type.