X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=python%2Fguestfs.py;h=23aef9c280a0cb62fc05e5f2e456cb5829d04d82;hp=0a4c3960b1a51c964bc56959b9ce0f08829f2f3a;hb=215041c7178922341ecbfdb23eb203f2bb8c29c4;hpb=1765330e07a48dc6f7bdef7007f69ebe606fa731 diff --git a/python/guestfs.py b/python/guestfs.py index 0a4c396..23aef9c 100644 --- a/python/guestfs.py +++ b/python/guestfs.py @@ -78,6 +78,87 @@ class GuestFS: def __del__ (self): libguestfsmod.close (self._o) + def test0 (self, str, optstr, strlist, b, integer, filein, fileout): + return libguestfsmod.test0 (self._o, str, optstr, strlist, b, integer, filein, fileout) + + def test0rint (self, val): + return libguestfsmod.test0rint (self._o, val) + + def test0rinterr (self): + return libguestfsmod.test0rinterr (self._o) + + def test0rint64 (self, val): + return libguestfsmod.test0rint64 (self._o, val) + + def test0rint64err (self): + return libguestfsmod.test0rint64err (self._o) + + def test0rbool (self, val): + return libguestfsmod.test0rbool (self._o, val) + + def test0rboolerr (self): + return libguestfsmod.test0rboolerr (self._o) + + def test0rconststring (self, val): + return libguestfsmod.test0rconststring (self._o, val) + + def test0rconststringerr (self): + return libguestfsmod.test0rconststringerr (self._o) + + def test0rstring (self, val): + return libguestfsmod.test0rstring (self._o, val) + + def test0rstringerr (self): + return libguestfsmod.test0rstringerr (self._o) + + def test0rstringlist (self, val): + return libguestfsmod.test0rstringlist (self._o, val) + + def test0rstringlisterr (self): + return libguestfsmod.test0rstringlisterr (self._o) + + def test0rintbool (self, val): + return libguestfsmod.test0rintbool (self._o, val) + + def test0rintboolerr (self): + return libguestfsmod.test0rintboolerr (self._o) + + def test0rpvlist (self, val): + return libguestfsmod.test0rpvlist (self._o, val) + + def test0rpvlisterr (self): + return libguestfsmod.test0rpvlisterr (self._o) + + def test0rvglist (self, val): + return libguestfsmod.test0rvglist (self._o, val) + + def test0rvglisterr (self): + return libguestfsmod.test0rvglisterr (self._o) + + def test0rlvlist (self, val): + return libguestfsmod.test0rlvlist (self._o, val) + + def test0rlvlisterr (self): + return libguestfsmod.test0rlvlisterr (self._o) + + def test0rstat (self, val): + return libguestfsmod.test0rstat (self._o, val) + + def test0rstaterr (self): + return libguestfsmod.test0rstaterr (self._o) + + def test0rstatvfs (self, val): + return libguestfsmod.test0rstatvfs (self._o, val) + + def test0rstatvfserr (self): + return libguestfsmod.test0rstatvfserr (self._o) + + def test0rhashtable (self, val): + return libguestfsmod.test0rhashtable (self._o, val) + + def test0rhashtableerr (self): + return libguestfsmod.test0rhashtableerr (self._o) + def launch (self): u"""Internally libguestfs is implemented by running a virtual machine using qemu(1). @@ -116,7 +197,13 @@ class GuestFS: to modify the image). This is equivalent to the qemu parameter "-drive - file=filename". + file=filename,cache=off". + + Note that this call checks for the existence of + "filename". This stops you from specifying other types + of drive which are supported by qemu such as "nbd:" and + "http:" URLs. To specify those, use the general + "g.config" call instead. """ return libguestfsmod.add_drive (self._o, filename) @@ -126,9 +213,37 @@ class GuestFS: This is equivalent to the qemu parameter "-cdrom filename". + + Note that this call checks for the existence of + "filename". This stops you from specifying other types + of drive which are supported by qemu such as "nbd:" and + "http:" URLs. To specify those, use the general + "g.config" call instead. """ return libguestfsmod.add_cdrom (self._o, filename) + def add_drive_ro (self, filename): + u"""This adds a drive in snapshot mode, making it + effectively read-only. + + Note that writes to the device are allowed, and will be + seen for the duration of the guestfs handle, but they + are written to a temporary file which is discarded as + soon as the guestfs handle is closed. We don't currently + have any method to enable changes to be committed, + although qemu can support this. + + This is equivalent to the qemu parameter "-drive + file=filename,snapshot=on". + + Note that this call checks for the existence of + "filename". This stops you from specifying other types + of drive which are supported by qemu such as "nbd:" and + "http:" URLs. To specify those, use the general + "g.config" call instead. + """ + return libguestfsmod.add_drive_ro (self._o, filename) + def config (self, qemuparam, qemuvalue): u"""This can be used to add arbitrary qemu command line parameters of the form "-param value". Actually it's not @@ -143,6 +258,28 @@ class GuestFS: """ return libguestfsmod.config (self._o, qemuparam, qemuvalue) + def set_qemu (self, qemu): + u"""Set the qemu binary that we will use. + + The default is chosen when the library was compiled by + the configure script. + + You can also override this by setting the + "LIBGUESTFS_QEMU" environment variable. + + Setting "qemu" to "NULL" restores the default qemu + binary. + """ + return libguestfsmod.set_qemu (self._o, qemu) + + def get_qemu (self): + u"""Return the current qemu binary. + + This is always non-NULL. If it wasn't set already, then + this will return the default qemu binary name. + """ + return libguestfsmod.get_qemu (self._o) + def set_path (self, path): u"""Set the path that libguestfs searches for kernel and initrd.img. @@ -150,10 +287,6 @@ class GuestFS: The default is "$libdir/guestfs" unless overridden by setting "LIBGUESTFS_PATH" environment variable. - The string "path" is stashed in the libguestfs handle, - so the caller must make sure it remains valid for the - lifetime of the handle. - Setting "path" to "NULL" restores the default path. """ return libguestfsmod.set_path (self._o, path) @@ -166,11 +299,34 @@ class GuestFS: """ return libguestfsmod.get_path (self._o) + def set_append (self, append): + u"""This function is used to add additional options to the + guest kernel command line. + + The default is "NULL" unless overridden by setting + "LIBGUESTFS_APPEND" environment variable. + + Setting "append" to "NULL" means *no* additional options + are passed (libguestfs always adds a few of its own). + """ + return libguestfsmod.set_append (self._o, append) + + def get_append (self): + u"""Return the additional kernel options which are added to + the guest kernel command line. + + If "NULL" then no options are added. + """ + return libguestfsmod.get_append (self._o) + def set_autosync (self, autosync): u"""If "autosync" is true, this enables autosync. Libguestfs - will make a best effort attempt to run "g.sync" when the - handle is closed (also if the program exits without - closing handles). + will make a best effort attempt to run "g.umount_all" + followed by "g.sync" when the handle is closed (also if + the program exits without closing handles). + + This is disabled by default (except in guestfish where + it is enabled by default). """ return libguestfsmod.set_autosync (self._o, autosync) @@ -193,6 +349,72 @@ class GuestFS: """ return libguestfsmod.get_verbose (self._o) + def is_ready (self): + u"""This returns true iff this handle is ready to accept + commands (in the "READY" state). + + For more information on states, see guestfs(3). + """ + return libguestfsmod.is_ready (self._o) + + def is_config (self): + u"""This returns true iff this handle is being configured + (in the "CONFIG" state). + + For more information on states, see guestfs(3). + """ + return libguestfsmod.is_config (self._o) + + def is_launching (self): + u"""This returns true iff this handle is launching the + subprocess (in the "LAUNCHING" state). + + For more information on states, see guestfs(3). + """ + return libguestfsmod.is_launching (self._o) + + def is_busy (self): + u"""This returns true iff this handle is busy processing a + command (in the "BUSY" state). + + For more information on states, see guestfs(3). + """ + return libguestfsmod.is_busy (self._o) + + def get_state (self): + u"""This returns the current state as an opaque integer. + This is only useful for printing debug and internal + error messages. + + For more information on states, see guestfs(3). + """ + return libguestfsmod.get_state (self._o) + + def set_busy (self): + u"""This sets the state to "BUSY". This is only used when + implementing actions using the low-level API. + + For more information on states, see guestfs(3). + """ + return libguestfsmod.set_busy (self._o) + + def set_ready (self): + u"""This sets the state to "READY". This is only used when + implementing actions using the low-level API. + + For more information on states, see guestfs(3). + """ + return libguestfsmod.set_ready (self._o) + + def end_busy (self): + u"""This sets the state to "READY", or if in "CONFIG" then + it leaves the state as is. This is only used when + implementing actions using the low-level API. + + For more information on states, see guestfs(3). + """ + return libguestfsmod.end_busy (self._o) + def mount (self, device, mountpoint): u"""Mount a guest disk at a position in the filesystem. Block devices are named "/dev/sda", "/dev/sdb" and so @@ -614,7 +836,7 @@ class GuestFS: def mkfs (self, fstype, device): u"""This creates a filesystem on "device" (usually a - partition of LVM logical volume). The filesystem type is + partition or LVM logical volume). The filesystem type is "fstype", for example "ext3". """ return libguestfsmod.mkfs (self._o, fstype, device) @@ -643,6 +865,8 @@ class GuestFS: you would pass "lines" as a single element list, when the single element being the string "," (comma). + See also: "g.sfdisk_l", "g.sfdisk_N" + This command is dangerous. Without careful use you can easily destroy all your data. """ @@ -657,6 +881,11 @@ class GuestFS: calculated using "strlen" (so in this case the content cannot contain embedded ASCII NULs). + *NB.* Owing to a bug, writing content containing ASCII + NUL characters does *not* work, even if the length is + specified. We hope to resolve this bug in a future + version. In the meantime use "g.upload". + Because of the message protocol, there is a transfer limit of somewhere between 2MB and 4MB. To transfer large files you should use FTP. @@ -718,7 +947,16 @@ class GuestFS: The single parameter is an argv-style list of arguments. The first element is the name of the program to run. Subsequent elements are parameters. The list must be - non-empty (ie. must contain a program name). + non-empty (ie. must contain a program name). Note that + the command runs directly, and is *not* invoked via the + shell (see "g.sh"). + + The return value is anything printed to *stdout* by the + command. + + If the command returns a non-zero exit status, then this + function returns an error message. The error message + string is the content of *stderr* from the command. The $PATH environment variable will contain at least "/usr/bin" and "/bin". If you require a program from @@ -730,6 +968,10 @@ class GuestFS: the correct places. It is the caller's responsibility to ensure all filesystems that are needed are mounted at the right locations. + + Because of the message protocol, there is a transfer + limit of somewhere between 2MB and 4MB. To transfer + large files you should use FTP. """ return libguestfsmod.command (self._o, arguments) @@ -737,7 +979,13 @@ class GuestFS: u"""This is the same as "g.command", but splits the result into a list of lines. + See also: "g.sh_lines" + This function returns a list of strings. + + Because of the message protocol, there is a transfer + limit of somewhere between 2MB and 4MB. To transfer + large files you should use FTP. """ return libguestfsmod.command_lines (self._o, arguments) @@ -779,8 +1027,8 @@ class GuestFS: return libguestfsmod.statvfs (self._o, path) def tune2fs_l (self, device): - u"""This returns the contents of the ext2 or ext3 filesystem - superblock on "device". + u"""This returns the contents of the ext2, ext3 or ext4 + filesystem superblock on "device". It is the same as running "tune2fs -l device". See tune2fs(8) manpage for more details. The list of fields @@ -882,3 +1130,600 @@ class GuestFS: """ return libguestfsmod.blockdev_rereadpt (self._o, device) + def upload (self, filename, remotefilename): + u"""Upload local file "filename" to "remotefilename" on the + filesystem. + + "filename" can also be a named pipe. + + See also "g.download". + """ + return libguestfsmod.upload (self._o, filename, remotefilename) + + def download (self, remotefilename, filename): + u"""Download file "remotefilename" and save it as "filename" + on the local machine. + + "filename" can also be a named pipe. + + See also "g.upload", "g.cat". + """ + return libguestfsmod.download (self._o, remotefilename, filename) + + def checksum (self, csumtype, path): + u"""This call computes the MD5, SHAx or CRC checksum of the + file named "path". + + The type of checksum to compute is given by the + "csumtype" parameter which must have one of the + following values: + + "crc" + Compute the cyclic redundancy check (CRC) specified + by POSIX for the "cksum" command. + + "md5" + Compute the MD5 hash (using the "md5sum" program). + + "sha1" + Compute the SHA1 hash (using the "sha1sum" program). + + "sha224" + Compute the SHA224 hash (using the "sha224sum" + program). + + "sha256" + Compute the SHA256 hash (using the "sha256sum" + program). + + "sha384" + Compute the SHA384 hash (using the "sha384sum" + program). + + "sha512" + Compute the SHA512 hash (using the "sha512sum" + program). + + The checksum is returned as a printable string. + """ + return libguestfsmod.checksum (self._o, csumtype, path) + + def tar_in (self, tarfile, directory): + u"""This command uploads and unpacks local file "tarfile" + (an *uncompressed* tar file) into "directory". + + To upload a compressed tarball, use "g.tgz_in". + """ + return libguestfsmod.tar_in (self._o, tarfile, directory) + + def tar_out (self, directory, tarfile): + u"""This command packs the contents of "directory" and + downloads it to local file "tarfile". + + To download a compressed tarball, use "g.tgz_out". + """ + return libguestfsmod.tar_out (self._o, directory, tarfile) + + def tgz_in (self, tarball, directory): + u"""This command uploads and unpacks local file "tarball" (a + *gzip compressed* tar file) into "directory". + + To upload an uncompressed tarball, use "g.tar_in". + """ + return libguestfsmod.tgz_in (self._o, tarball, directory) + + def tgz_out (self, directory, tarball): + u"""This command packs the contents of "directory" and + downloads it to local file "tarball". + + To download an uncompressed tarball, use "g.tar_out". + """ + return libguestfsmod.tgz_out (self._o, directory, tarball) + + def mount_ro (self, device, mountpoint): + u"""This is the same as the "g.mount" command, but it mounts + the filesystem with the read-only (*-o ro*) flag. + """ + return libguestfsmod.mount_ro (self._o, device, mountpoint) + + def mount_options (self, options, device, mountpoint): + u"""This is the same as the "g.mount" command, but it allows + you to set the mount options as for the mount(8) *-o* + flag. + """ + return libguestfsmod.mount_options (self._o, options, device, mountpoint) + + def mount_vfs (self, options, vfstype, device, mountpoint): + u"""This is the same as the "g.mount" command, but it allows + you to set both the mount options and the vfstype as for + the mount(8) *-o* and *-t* flags. + """ + return libguestfsmod.mount_vfs (self._o, options, vfstype, device, mountpoint) + + def debug (self, subcmd, extraargs): + u"""The "g.debug" command exposes some internals of + "guestfsd" (the guestfs daemon) that runs inside the + qemu subprocess. + + There is no comprehensive help for this command. You + have to look at the file "daemon/debug.c" in the + libguestfs source to find out what you can do. + """ + return libguestfsmod.debug (self._o, subcmd, extraargs) + + def lvremove (self, device): + u"""Remove an LVM logical volume "device", where "device" is + the path to the LV, such as "/dev/VG/LV". + + You can also remove all LVs in a volume group by + specifying the VG name, "/dev/VG". + """ + return libguestfsmod.lvremove (self._o, device) + + def vgremove (self, vgname): + u"""Remove an LVM volume group "vgname", (for example "VG"). + + This also forcibly removes all logical volumes in the + volume group (if any). + """ + return libguestfsmod.vgremove (self._o, vgname) + + def pvremove (self, device): + u"""This wipes a physical volume "device" so that LVM will + no longer recognise it. + + The implementation uses the "pvremove" command which + refuses to wipe physical volumes that contain any volume + groups, so you have to remove those first. + """ + return libguestfsmod.pvremove (self._o, device) + + def set_e2label (self, device, label): + u"""This sets the ext2/3/4 filesystem label of the + filesystem on "device" to "label". Filesystem labels are + limited to 16 characters. + + You can use either "g.tune2fs_l" or "g.get_e2label" to + return the existing label on a filesystem. + """ + return libguestfsmod.set_e2label (self._o, device, label) + + def get_e2label (self, device): + u"""This returns the ext2/3/4 filesystem label of the + filesystem on "device". + """ + return libguestfsmod.get_e2label (self._o, device) + + def set_e2uuid (self, device, uuid): + u"""This sets the ext2/3/4 filesystem UUID of the filesystem + on "device" to "uuid". The format of the UUID and + alternatives such as "clear", "random" and "time" are + described in the tune2fs(8) manpage. + + You can use either "g.tune2fs_l" or "g.get_e2uuid" to + return the existing UUID of a filesystem. + """ + return libguestfsmod.set_e2uuid (self._o, device, uuid) + + def get_e2uuid (self, device): + u"""This returns the ext2/3/4 filesystem UUID of the + filesystem on "device". + """ + return libguestfsmod.get_e2uuid (self._o, device) + + def fsck (self, fstype, device): + u"""This runs the filesystem checker (fsck) on "device" + which should have filesystem type "fstype". + + The returned integer is the status. See fsck(8) for the + list of status codes from "fsck". + + Notes: + + * Multiple status codes can be summed together. + + * A non-zero return code can mean "success", for + example if errors have been corrected on the + filesystem. + + * Checking or repairing NTFS volumes is not supported + (by linux-ntfs). + + This command is entirely equivalent to running "fsck -a + -t fstype device". + """ + return libguestfsmod.fsck (self._o, fstype, device) + + def zero (self, device): + u"""This command writes zeroes over the first few blocks of + "device". + + How many blocks are zeroed isn't specified (but it's + *not* enough to securely wipe the device). It should be + sufficient to remove any partition tables, filesystem + superblocks and so on. + + See also: "g.scrub_device". + """ + return libguestfsmod.zero (self._o, device) + + def grub_install (self, root, device): + u"""This command installs GRUB (the Grand Unified + Bootloader) on "device", with the root directory being + "root". + """ + return libguestfsmod.grub_install (self._o, root, device) + + def cp (self, src, dest): + u"""This copies a file from "src" to "dest" where "dest" is + either a destination filename or destination directory. + """ + return libguestfsmod.cp (self._o, src, dest) + + def cp_a (self, src, dest): + u"""This copies a file or directory from "src" to "dest" + recursively using the "cp -a" command. + """ + return libguestfsmod.cp_a (self._o, src, dest) + + def mv (self, src, dest): + u"""This moves a file from "src" to "dest" where "dest" is + either a destination filename or destination directory. + """ + return libguestfsmod.mv (self._o, src, dest) + + def drop_caches (self, whattodrop): + u"""This instructs the guest kernel to drop its page cache, + and/or dentries and inode caches. The parameter + "whattodrop" tells the kernel what precisely to drop, + see + + Setting "whattodrop" to 3 should drop everything. + + This automatically calls sync(2) before the operation, + so that the maximum guest memory is freed. + """ + return libguestfsmod.drop_caches (self._o, whattodrop) + + def dmesg (self): + u"""This returns the kernel messages ("dmesg" output) from + the guest kernel. This is sometimes useful for extended + debugging of problems. + + Another way to get the same information is to enable + verbose messages with "g.set_verbose" or by setting the + environment variable "LIBGUESTFS_DEBUG=1" before running + the program. + """ + return libguestfsmod.dmesg (self._o) + + def ping_daemon (self): + u"""This is a test probe into the guestfs daemon running + inside the qemu subprocess. Calling this function checks + that the daemon responds to the ping message, without + affecting the daemon or attached block device(s) in any + other way. + """ + return libguestfsmod.ping_daemon (self._o) + + def equal (self, file1, file2): + u"""This compares the two files "file1" and "file2" and + returns true if their content is exactly equal, or false + otherwise. + + The external cmp(1) program is used for the comparison. + """ + return libguestfsmod.equal (self._o, file1, file2) + + def strings (self, path): + u"""This runs the strings(1) command on a file and returns + the list of printable strings found. + + This function returns a list of strings. + + Because of the message protocol, there is a transfer + limit of somewhere between 2MB and 4MB. To transfer + large files you should use FTP. + """ + return libguestfsmod.strings (self._o, path) + + def strings_e (self, encoding, path): + u"""This is like the "g.strings" command, but allows you to + specify the encoding. + + See the strings(1) manpage for the full list of + encodings. + + Commonly useful encodings are "l" (lower case L) which + will show strings inside Windows/x86 files. + + The returned strings are transcoded to UTF-8. + + This function returns a list of strings. + + Because of the message protocol, there is a transfer + limit of somewhere between 2MB and 4MB. To transfer + large files you should use FTP. + """ + return libguestfsmod.strings_e (self._o, encoding, path) + + def hexdump (self, path): + u"""This runs "hexdump -C" on the given "path". The result + is the human-readable, canonical hex dump of the file. + + Because of the message protocol, there is a transfer + limit of somewhere between 2MB and 4MB. To transfer + large files you should use FTP. + """ + return libguestfsmod.hexdump (self._o, path) + + def zerofree (self, device): + u"""This runs the *zerofree* program on "device". This + program claims to zero unused inodes and disk blocks on + an ext2/3 filesystem, thus making it possible to + compress the filesystem more effectively. + + You should not run this program if the filesystem is + mounted. + + It is possible that using this program can damage the + filesystem or data on the filesystem. + """ + return libguestfsmod.zerofree (self._o, device) + + def pvresize (self, device): + u"""This resizes (expands or shrinks) an existing LVM + physical volume to match the new size of the underlying + device. + """ + return libguestfsmod.pvresize (self._o, device) + + def sfdisk_N (self, device, n, cyls, heads, sectors, line): + u"""This runs sfdisk(8) option to modify just the single + partition "n" (note: "n" counts from 1). + + For other parameters, see "g.sfdisk". You should usually + pass 0 for the cyls/heads/sectors parameters. + + This command is dangerous. Without careful use you can + easily destroy all your data. + """ + return libguestfsmod.sfdisk_N (self._o, device, n, cyls, heads, sectors, line) + + def sfdisk_l (self, device): + u"""This displays the partition table on "device", in the + human-readable output of the sfdisk(8) command. It is + not intended to be parsed. + """ + return libguestfsmod.sfdisk_l (self._o, device) + + def sfdisk_kernel_geometry (self, device): + u"""This displays the kernel's idea of the geometry of + "device". + + The result is in human-readable format, and not designed + to be parsed. + """ + return libguestfsmod.sfdisk_kernel_geometry (self._o, device) + + def sfdisk_disk_geometry (self, device): + u"""This displays the disk geometry of "device" read from + the partition table. Especially in the case where the + underlying block device has been resized, this can be + different from the kernel's idea of the geometry (see + "g.sfdisk_kernel_geometry"). + + The result is in human-readable format, and not designed + to be parsed. + """ + return libguestfsmod.sfdisk_disk_geometry (self._o, device) + + def vg_activate_all (self, activate): + u"""This command activates or (if "activate" is false) + deactivates all logical volumes in all volume groups. If + activated, then they are made known to the kernel, ie. + they appear as "/dev/mapper" devices. If deactivated, + then those devices disappear. + + This command is the same as running "vgchange -a y|n" + """ + return libguestfsmod.vg_activate_all (self._o, activate) + + def vg_activate (self, activate, volgroups): + u"""This command activates or (if "activate" is false) + deactivates all logical volumes in the listed volume + groups "volgroups". If activated, then they are made + known to the kernel, ie. they appear as "/dev/mapper" + devices. If deactivated, then those devices disappear. + + This command is the same as running "vgchange -a y|n + volgroups..." + + Note that if "volgroups" is an empty list then all + volume groups are activated or deactivated. + """ + return libguestfsmod.vg_activate (self._o, activate, volgroups) + + def lvresize (self, device, mbytes): + u"""This resizes (expands or shrinks) an existing LVM + logical volume to "mbytes". When reducing, data in the + reduced part is lost. + """ + return libguestfsmod.lvresize (self._o, device, mbytes) + + def resize2fs (self, device): + u"""This resizes an ext2 or ext3 filesystem to match the + size of the underlying device. + + *Note:* It is sometimes required that you run + "g.e2fsck_f" on the "device" before calling this + command. For unknown reasons "resize2fs" sometimes gives + an error about this and sometimes not. In any case, it + is always safe to call "g.e2fsck_f" before calling this + function. + """ + return libguestfsmod.resize2fs (self._o, device) + + def find (self, directory): + u"""This command lists out all files and directories, + recursively, starting at "directory". It is essentially + equivalent to running the shell command "find directory + -print" but some post-processing happens on the output, + described below. + + This returns a list of strings *without any prefix*. + Thus if the directory structure was: + + /tmp/a + /tmp/b + /tmp/c/d + + then the returned list from "g.find" "/tmp" would be 4 + elements: + + a + b + c + c/d + + If "directory" is not a directory, then this command + returns an error. + + The returned list is sorted. + + This function returns a list of strings. + """ + return libguestfsmod.find (self._o, directory) + + def e2fsck_f (self, device): + u"""This runs "e2fsck -p -f device", ie. runs the ext2/ext3 + filesystem checker on "device", noninteractively ("-p"), + even if the filesystem appears to be clean ("-f"). + + This command is only needed because of "g.resize2fs" + (q.v.). Normally you should use "g.fsck". + """ + return libguestfsmod.e2fsck_f (self._o, device) + + def sleep (self, secs): + u"""Sleep for "secs" seconds. + """ + return libguestfsmod.sleep (self._o, secs) + + def ntfs_3g_probe (self, rw, device): + u"""This command runs the ntfs-3g.probe(8) command which + probes an NTFS "device" for mountability. (Not all NTFS + volumes can be mounted read-write, and some cannot be + mounted at all). + + "rw" is a boolean flag. Set it to true if you want to + test if the volume can be mounted read-write. Set it to + false if you want to test if the volume can be mounted + read-only. + + The return value is an integer which 0 if the operation + would succeed, or some non-zero value documented in the + ntfs-3g.probe(8) manual page. + """ + return libguestfsmod.ntfs_3g_probe (self._o, rw, device) + + def sh (self, command): + u"""This call runs a command from the guest filesystem via + the guest's "/bin/sh". + + This is like "g.command", but passes the command to: + + /bin/sh -c "command" + + Depending on the guest's shell, this usually results in + wildcards being expanded, shell expressions being + interpolated and so on. + + All the provisos about "g.command" apply to this call. + """ + return libguestfsmod.sh (self._o, command) + + def sh_lines (self, command): + u"""This is the same as "g.sh", but splits the result into a + list of lines. + + See also: "g.command_lines" + + This function returns a list of strings. + """ + return libguestfsmod.sh_lines (self._o, command) + + def glob_expand (self, pattern): + u"""This command searches for all the pathnames matching + "pattern" according to the wildcard expansion rules used + by the shell. + + If no paths match, then this returns an empty list + (note: not an error). + + It is just a wrapper around the C glob(3) function with + flags "GLOB_MARK|GLOB_BRACE". See that manual page for + more details. + + This function returns a list of strings. + """ + return libguestfsmod.glob_expand (self._o, pattern) + + def scrub_device (self, device): + u"""This command writes patterns over "device" to make data + retrieval more difficult. + + It is an interface to the scrub(1) program. See that + manual page for more details. + + This command is dangerous. Without careful use you can + easily destroy all your data. + """ + return libguestfsmod.scrub_device (self._o, device) + + def scrub_file (self, file): + u"""This command writes patterns over a file to make data + retrieval more difficult. + + The file is *removed* after scrubbing. + + It is an interface to the scrub(1) program. See that + manual page for more details. + """ + return libguestfsmod.scrub_file (self._o, file) + + def scrub_freespace (self, dir): + u"""This command creates the directory "dir" and then fills + it with files until the filesystem is full, and scrubs + the files as for "g.scrub_file", and deletes them. The + intention is to scrub any free space on the partition + containing "dir". + + It is an interface to the scrub(1) program. See that + manual page for more details. + """ + return libguestfsmod.scrub_freespace (self._o, dir) + + def mkdtemp (self, template): + u"""This command creates a temporary directory. The + "template" parameter should be a full pathname for the + temporary directory name with the final six characters + being "XXXXXX". + + For example: "/tmp/myprogXXXXXX" or + "/Temp/myprogXXXXXX", the second one being suitable for + Windows filesystems. + + The name of the temporary directory that was created is + returned. + + The temporary directory is created with mode 0700 and is + owned by root. + + The caller is responsible for deleting the temporary + directory and its contents after use. + + See also: mkdtemp(3) + """ + return libguestfsmod.mkdtemp (self._o, template) +