X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=python%2Fguestfs.py;fp=python%2Fguestfs.py;h=0000000000000000000000000000000000000000;hp=784c5671cfd5f43342a7dbe3b70ab308a991388c;hb=b3cb0b04eb2d38ba32c160a83d8e3894b376907b;hpb=da85ed425dc828ef4b8817f64d448101a88507b5 diff --git a/python/guestfs.py b/python/guestfs.py deleted file mode 100644 index 784c567..0000000 --- a/python/guestfs.py +++ /dev/null @@ -1,1977 +0,0 @@ -# libguestfs generated file -# WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'. -# ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST. -# -# Copyright (C) 2009 Red Hat Inc. -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2 of the License, or (at your option) any later version. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - -u"""Python bindings for libguestfs - -import guestfs -g = guestfs.GuestFS () -g.add_drive ("guest.img") -g.launch () -g.wait_ready () -parts = g.list_partitions () - -The guestfs module provides a Python binding to the libguestfs API -for examining and modifying virtual machine disk images. - -Amongst the things this is good for: making batch configuration -changes to guests, getting disk used/free statistics (see also: -virt-df), migrating between virtualization systems (see also: -virt-p2v), performing partial backups, performing partial guest -clones, cloning guests and changing registry/UUID/hostname info, and -much else besides. - -Libguestfs uses Linux kernel and qemu code, and can access any type of -guest filesystem that Linux and qemu can, including but not limited -to: ext2/3/4, btrfs, FAT and NTFS, LVM, many different disk partition -schemes, qcow, qcow2, vmdk. - -Libguestfs provides ways to enumerate guest storage (eg. partitions, -LVs, what filesystem is in each LV, etc.). It can also run commands -in the context of the guest. Also you can access filesystems over FTP. - -Errors which happen while using the API are turned into Python -RuntimeError exceptions. - -To create a guestfs handle you usually have to perform the following -sequence of calls: - -# Create the handle, call add_drive at least once, and possibly -# several times if the guest has multiple block devices: -g = guestfs.GuestFS () -g.add_drive ("guest.img") - -# Launch the qemu subprocess and wait for it to become ready: -g.launch () -g.wait_ready () - -# Now you can issue commands, for example: -logvols = g.lvs () - -""" - -import libguestfsmod - -class GuestFS: - """Instances of this class are libguestfs API handles.""" - - def __init__ (self): - """Create a new libguestfs handle.""" - self._o = libguestfsmod.create () - - 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). - - You should call this after configuring the handle (eg. - adding drives) but before performing any actions. - """ - return libguestfsmod.launch (self._o) - - def wait_ready (self): - u"""Internally libguestfs is implemented by running a - virtual machine using qemu(1). - - You should call this after "g.launch" to wait for the - launch to complete. - """ - return libguestfsmod.wait_ready (self._o) - - def kill_subprocess (self): - u"""This kills the qemu subprocess. You should never need to - call this. - """ - return libguestfsmod.kill_subprocess (self._o) - - def add_drive (self, filename): - u"""This function adds a virtual machine disk image - "filename" to the guest. The first time you call this - function, the disk appears as IDE disk 0 ("/dev/sda") in - the guest, the second time as "/dev/sdb", and so on. - - You don't necessarily need to be root when using - libguestfs. However you obviously do need sufficient - permissions to access the filename for whatever - operations you want to perform (ie. read access if you - just want to read the image or write access if you want - to modify the image). - - This is equivalent to the qemu parameter "-drive - file=filename,cache=off,if=virtio". - - 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) - - def add_cdrom (self, filename): - u"""This function adds a virtual CD-ROM disk image to the - guest. - - 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,if=virtio". - - 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 - quite arbitrary - we prevent you from setting some - parameters which would interfere with parameters that we - use. - - The first character of "param" string must be a "-" - (dash). - - "value" can be NULL. - """ - 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. - - The default is "$libdir/guestfs" unless overridden by - setting "LIBGUESTFS_PATH" environment variable. - - Setting "path" to "NULL" restores the default path. - """ - return libguestfsmod.set_path (self._o, path) - - def get_path (self): - u"""Return the current search path. - - This is always non-NULL. If it wasn't set already, then - this will return the default path. - """ - 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.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) - - def get_autosync (self): - u"""Get the autosync flag. - """ - return libguestfsmod.get_autosync (self._o) - - def set_verbose (self, verbose): - u"""If "verbose" is true, this turns on verbose messages (to - "stderr"). - - Verbose messages are disabled unless the environment - variable "LIBGUESTFS_DEBUG" is defined and set to 1. - """ - return libguestfsmod.set_verbose (self._o, verbose) - - def get_verbose (self): - u"""This returns the verbose messages flag. - """ - 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 set_memsize (self, memsize): - u"""This sets the memory size in megabytes allocated to the - qemu subprocess. This only has any effect if called - before "g.launch". - - You can also change this by setting the environment - variable "LIBGUESTFS_MEMSIZE" before the handle is - created. - - For more information on the architecture of libguestfs, - see guestfs(3). - """ - return libguestfsmod.set_memsize (self._o, memsize) - - def get_memsize (self): - u"""This gets the memory size in megabytes allocated to the - qemu subprocess. - - If "g.set_memsize" was not called on this handle, and if - "LIBGUESTFS_MEMSIZE" was not set, then this returns the - compiled-in default value for memsize. - - For more information on the architecture of libguestfs, - see guestfs(3). - """ - return libguestfsmod.get_memsize (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 - on, as they were added to the guest. If those block - devices contain partitions, they will have the usual - names (eg. "/dev/sda1"). Also LVM "/dev/VG/LV"-style - names can be used. - - The rules are the same as for mount(2): A filesystem - must first be mounted on "/" before others can be - mounted. Other filesystems can only be mounted on - directories which already exist. - - The mounted filesystem is writable, if we have - sufficient permissions on the underlying device. - - The filesystem options "sync" and "noatime" are set with - this call, in order to improve reliability. - """ - return libguestfsmod.mount (self._o, device, mountpoint) - - def sync (self): - u"""This syncs the disk, so that any writes are flushed - through to the underlying disk image. - - You should always call this if you have modified a disk - image, before closing the handle. - """ - return libguestfsmod.sync (self._o) - - def touch (self, path): - u"""Touch acts like the touch(1) command. It can be used to - update the timestamps on a file, or, if the file does - not exist, to create a new zero-length file. - """ - return libguestfsmod.touch (self._o, path) - - def cat (self, path): - u"""Return the contents of the file named "path". - - Note that this function cannot correctly handle binary - files (specifically, files containing "\\0" character - which is treated as end of string). For those you need - to use the "g.download" function which has a more - complex interface. - - 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.cat (self._o, path) - - def ll (self, directory): - u"""List the files in "directory" (relative to the root - directory, there is no cwd) in the format of 'ls -la'. - - This command is mostly useful for interactive sessions. - It is *not* intended that you try to parse the output - string. - """ - return libguestfsmod.ll (self._o, directory) - - def ls (self, directory): - u"""List the files in "directory" (relative to the root - directory, there is no cwd). The '.' and '..' entries - are not returned, but hidden files are shown. - - This command is mostly useful for interactive sessions. - Programs should probably use "g.readdir" instead. - - This function returns a list of strings. - """ - return libguestfsmod.ls (self._o, directory) - - def list_devices (self): - u"""List all the block devices. - - The full block device names are returned, eg. "/dev/sda" - - This function returns a list of strings. - """ - return libguestfsmod.list_devices (self._o) - - def list_partitions (self): - u"""List all the partitions detected on all block devices. - - The full partition device names are returned, eg. - "/dev/sda1" - - This does not return logical volumes. For that you will - need to call "g.lvs". - - This function returns a list of strings. - """ - return libguestfsmod.list_partitions (self._o) - - def pvs (self): - u"""List all the physical volumes detected. This is the - equivalent of the pvs(8) command. - - This returns a list of just the device names that - contain PVs (eg. "/dev/sda2"). - - See also "g.pvs_full". - - This function returns a list of strings. - """ - return libguestfsmod.pvs (self._o) - - def vgs (self): - u"""List all the volumes groups detected. This is the - equivalent of the vgs(8) command. - - This returns a list of just the volume group names that - were detected (eg. "VolGroup00"). - - See also "g.vgs_full". - - This function returns a list of strings. - """ - return libguestfsmod.vgs (self._o) - - def lvs (self): - u"""List all the logical volumes detected. This is the - equivalent of the lvs(8) command. - - This returns a list of the logical volume device names - (eg. "/dev/VolGroup00/LogVol00"). - - See also "g.lvs_full". - - This function returns a list of strings. - """ - return libguestfsmod.lvs (self._o) - - def pvs_full (self): - u"""List all the physical volumes detected. This is the - equivalent of the pvs(8) command. The "full" version - includes all fields. - - This function returns a list of PVs. Each PV is - represented as a dictionary. - """ - return libguestfsmod.pvs_full (self._o) - - def vgs_full (self): - u"""List all the volumes groups detected. This is the - equivalent of the vgs(8) command. The "full" version - includes all fields. - - This function returns a list of VGs. Each VG is - represented as a dictionary. - """ - return libguestfsmod.vgs_full (self._o) - - def lvs_full (self): - u"""List all the logical volumes detected. This is the - equivalent of the lvs(8) command. The "full" version - includes all fields. - - This function returns a list of LVs. Each LV is - represented as a dictionary. - """ - return libguestfsmod.lvs_full (self._o) - - def read_lines (self, path): - u"""Return the contents of the file named "path". - - The file contents are returned as a list of lines. - Trailing "LF" and "CRLF" character sequences are *not* - returned. - - Note that this function cannot correctly handle binary - files (specifically, files containing "\\0" character - which is treated as end of line). For those you need to - use the "g.read_file" function which has a more complex - interface. - - This function returns a list of strings. - """ - return libguestfsmod.read_lines (self._o, path) - - def aug_init (self, root, flags): - u"""Create a new Augeas handle for editing configuration - files. If there was any previous Augeas handle - associated with this guestfs session, then it is closed. - - You must call this before using any other "g.aug_*" - commands. - - "root" is the filesystem root. "root" must not be NULL, - use "/" instead. - - The flags are the same as the flags defined in - , the logical *or* of the following integers: - - "AUG_SAVE_BACKUP" = 1 - Keep the original file with a ".augsave" extension. - - "AUG_SAVE_NEWFILE" = 2 - Save changes into a file with extension ".augnew", - and do not overwrite original. Overrides - "AUG_SAVE_BACKUP". - - "AUG_TYPE_CHECK" = 4 - Typecheck lenses (can be expensive). - - "AUG_NO_STDINC" = 8 - Do not use standard load path for modules. - - "AUG_SAVE_NOOP" = 16 - Make save a no-op, just record what would have been - changed. - - "AUG_NO_LOAD" = 32 - Do not load the tree in "g.aug_init". - - To close the handle, you can call "g.aug_close". - - To find out more about Augeas, see . - """ - return libguestfsmod.aug_init (self._o, root, flags) - - def aug_close (self): - u"""Close the current Augeas handle and free up any - resources used by it. After calling this, you have to - call "g.aug_init" again before you can use any other - Augeas functions. - """ - return libguestfsmod.aug_close (self._o) - - def aug_defvar (self, name, expr): - u"""Defines an Augeas variable "name" whose value is the - result of evaluating "expr". If "expr" is NULL, then - "name" is undefined. - - On success this returns the number of nodes in "expr", - or 0 if "expr" evaluates to something which is not a - nodeset. - """ - return libguestfsmod.aug_defvar (self._o, name, expr) - - def aug_defnode (self, name, expr, val): - u"""Defines a variable "name" whose value is the result of - evaluating "expr". - - If "expr" evaluates to an empty nodeset, a node is - created, equivalent to calling "g.aug_set" "expr", - "value". "name" will be the nodeset containing that - single node. - - On success this returns a pair containing the number of - nodes in the nodeset, and a boolean flag if a node was - created. - - This function returns a tuple (int, bool). - """ - return libguestfsmod.aug_defnode (self._o, name, expr, val) - - def aug_get (self, path): - u"""Look up the value associated with "path". If "path" - matches exactly one node, the "value" is returned. - """ - return libguestfsmod.aug_get (self._o, path) - - def aug_set (self, path, val): - u"""Set the value associated with "path" to "value". - """ - return libguestfsmod.aug_set (self._o, path, val) - - def aug_insert (self, path, label, before): - u"""Create a new sibling "label" for "path", inserting it - into the tree before or after "path" (depending on the - boolean flag "before"). - - "path" must match exactly one existing node in the tree, - and "label" must be a label, ie. not contain "/", "*" or - end with a bracketed index "[N]". - """ - return libguestfsmod.aug_insert (self._o, path, label, before) - - def aug_rm (self, path): - u"""Remove "path" and all of its children. - - On success this returns the number of entries which were - removed. - """ - return libguestfsmod.aug_rm (self._o, path) - - def aug_mv (self, src, dest): - u"""Move the node "src" to "dest". "src" must match exactly - one node. "dest" is overwritten if it exists. - """ - return libguestfsmod.aug_mv (self._o, src, dest) - - def aug_match (self, path): - u"""Returns a list of paths which match the path expression - "path". The returned paths are sufficiently qualified so - that they match exactly one node in the current tree. - - This function returns a list of strings. - """ - return libguestfsmod.aug_match (self._o, path) - - def aug_save (self): - u"""This writes all pending changes to disk. - - The flags which were passed to "g.aug_init" affect - exactly how files are saved. - """ - return libguestfsmod.aug_save (self._o) - - def aug_load (self): - u"""Load files into the tree. - - See "aug_load" in the Augeas documentation for the full - gory details. - """ - return libguestfsmod.aug_load (self._o) - - def aug_ls (self, path): - u"""This is just a shortcut for listing "g.aug_match" - "path/*" and sorting the resulting nodes into - alphabetical order. - - This function returns a list of strings. - """ - return libguestfsmod.aug_ls (self._o, path) - - def rm (self, path): - u"""Remove the single file "path". - """ - return libguestfsmod.rm (self._o, path) - - def rmdir (self, path): - u"""Remove the single directory "path". - """ - return libguestfsmod.rmdir (self._o, path) - - def rm_rf (self, path): - u"""Remove the file or directory "path", recursively - removing the contents if its a directory. This is like - the "rm -rf" shell command. - """ - return libguestfsmod.rm_rf (self._o, path) - - def mkdir (self, path): - u"""Create a directory named "path". - """ - return libguestfsmod.mkdir (self._o, path) - - def mkdir_p (self, path): - u"""Create a directory named "path", creating any parent - directories as necessary. This is like the "mkdir -p" - shell command. - """ - return libguestfsmod.mkdir_p (self._o, path) - - def chmod (self, mode, path): - u"""Change the mode (permissions) of "path" to "mode". Only - numeric modes are supported. - """ - return libguestfsmod.chmod (self._o, mode, path) - - def chown (self, owner, group, path): - u"""Change the file owner to "owner" and group to "group". - - Only numeric uid and gid are supported. If you want to - use names, you will need to locate and parse the - password file yourself (Augeas support makes this - relatively easy). - """ - return libguestfsmod.chown (self._o, owner, group, path) - - def exists (self, path): - u"""This returns "true" if and only if there is a file, - directory (or anything) with the given "path" name. - - See also "g.is_file", "g.is_dir", "g.stat". - """ - return libguestfsmod.exists (self._o, path) - - def is_file (self, path): - u"""This returns "true" if and only if there is a file with - the given "path" name. Note that it returns false for - other objects like directories. - - See also "g.stat". - """ - return libguestfsmod.is_file (self._o, path) - - def is_dir (self, path): - u"""This returns "true" if and only if there is a directory - with the given "path" name. Note that it returns false - for other objects like files. - - See also "g.stat". - """ - return libguestfsmod.is_dir (self._o, path) - - def pvcreate (self, device): - u"""This creates an LVM physical volume on the named - "device", where "device" should usually be a partition - name such as "/dev/sda1". - """ - return libguestfsmod.pvcreate (self._o, device) - - def vgcreate (self, volgroup, physvols): - u"""This creates an LVM volume group called "volgroup" from - the non-empty list of physical volumes "physvols". - """ - return libguestfsmod.vgcreate (self._o, volgroup, physvols) - - def lvcreate (self, logvol, volgroup, mbytes): - u"""This creates an LVM volume group called "logvol" on the - volume group "volgroup", with "size" megabytes. - """ - return libguestfsmod.lvcreate (self._o, logvol, volgroup, mbytes) - - def mkfs (self, fstype, device): - u"""This creates a filesystem on "device" (usually a - partition or LVM logical volume). The filesystem type is - "fstype", for example "ext3". - """ - return libguestfsmod.mkfs (self._o, fstype, device) - - def sfdisk (self, device, cyls, heads, sectors, lines): - u"""This is a direct interface to the sfdisk(8) program for - creating partitions on block devices. - - "device" should be a block device, for example - "/dev/sda". - - "cyls", "heads" and "sectors" are the number of - cylinders, heads and sectors on the device, which are - passed directly to sfdisk as the *-C*, *-H* and *-S* - parameters. If you pass 0 for any of these, then the - corresponding parameter is omitted. Usually for 'large' - disks, you can just pass 0 for these, but for small - (floppy-sized) disks, sfdisk (or rather, the kernel) - cannot work out the right geometry and you will need to - tell it. - - "lines" is a list of lines that we feed to "sfdisk". For - more information refer to the sfdisk(8) manpage. - - To create a single partition occupying the whole disk, - 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. - """ - return libguestfsmod.sfdisk (self._o, device, cyls, heads, sectors, lines) - - def write_file (self, path, content, size): - u"""This call creates a file called "path". The contents of - the file is the string "content" (which can contain any - 8 bit data), with length "size". - - As a special case, if "size" is 0 then the length is - 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. - """ - return libguestfsmod.write_file (self._o, path, content, size) - - def umount (self, pathordevice): - u"""This unmounts the given filesystem. The filesystem may - be specified either by its mountpoint (path) or the - device which contains the filesystem. - """ - return libguestfsmod.umount (self._o, pathordevice) - - def mounts (self): - u"""This returns the list of currently mounted filesystems. - It returns the list of devices (eg. "/dev/sda1", - "/dev/VG/LV"). - - Some internal mounts are not shown. - - This function returns a list of strings. - """ - return libguestfsmod.mounts (self._o) - - def umount_all (self): - u"""This unmounts all mounted filesystems. - - Some internal mounts are not unmounted by this call. - """ - return libguestfsmod.umount_all (self._o) - - def lvm_remove_all (self): - u"""This command removes all LVM logical volumes, volume - groups and physical volumes. - - This command is dangerous. Without careful use you can - easily destroy all your data. - """ - return libguestfsmod.lvm_remove_all (self._o) - - def file (self, path): - u"""This call uses the standard file(1) command to determine - the type or contents of the file. This also works on - devices, for example to find out whether a partition - contains a filesystem. - - The exact command which runs is "file -bsL path". Note - in particular that the filename is not prepended to the - output (the "-b" option). - """ - return libguestfsmod.file (self._o, path) - - def command (self, arguments): - u"""This call runs a command from the guest filesystem. The - filesystem must be mounted, and must contain a - compatible operating system (ie. something Linux, with - the same or compatible processor architecture). - - 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). 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 - another location, you should provide the full path in - the first parameter. - - Shared libraries and data files required by the program - must be available on filesystems which are mounted in - 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) - - def command_lines (self, arguments): - 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) - - def stat (self, path): - u"""Returns file information for the given "path". - - This is the same as the stat(2) system call. - - This function returns a dictionary, with keys matching - the various fields in the stat structure. - """ - return libguestfsmod.stat (self._o, path) - - def lstat (self, path): - u"""Returns file information for the given "path". - - This is the same as "g.stat" except that if "path" is a - symbolic link, then the link is stat-ed, not the file it - refers to. - - This is the same as the lstat(2) system call. - - This function returns a dictionary, with keys matching - the various fields in the stat structure. - """ - return libguestfsmod.lstat (self._o, path) - - def statvfs (self, path): - u"""Returns file system statistics for any mounted file - system. "path" should be a file or directory in the - mounted file system (typically it is the mount point - itself, but it doesn't need to be). - - This is the same as the statvfs(2) system call. - - This function returns a dictionary, with keys matching - the various fields in the statvfs structure. - """ - return libguestfsmod.statvfs (self._o, path) - - def tune2fs_l (self, 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 - returned isn't clearly defined, and depends on both the - version of "tune2fs" that libguestfs was built against, - and the filesystem itself. - - This function returns a dictionary. - """ - return libguestfsmod.tune2fs_l (self._o, device) - - def blockdev_setro (self, device): - u"""Sets the block device named "device" to read-only. - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_setro (self._o, device) - - def blockdev_setrw (self, device): - u"""Sets the block device named "device" to read-write. - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_setrw (self._o, device) - - def blockdev_getro (self, device): - u"""Returns a boolean indicating if the block device is - read-only (true if read-only, false if not). - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_getro (self._o, device) - - def blockdev_getss (self, device): - u"""This returns the size of sectors on a block device. - Usually 512, but can be larger for modern devices. - - (Note, this is not the size in sectors, use - "g.blockdev_getsz" for that). - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_getss (self._o, device) - - def blockdev_getbsz (self, device): - u"""This returns the block size of a device. - - (Note this is different from both *size in blocks* and - *filesystem block size*). - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_getbsz (self._o, device) - - def blockdev_setbsz (self, device, blocksize): - u"""This sets the block size of a device. - - (Note this is different from both *size in blocks* and - *filesystem block size*). - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_setbsz (self._o, device, blocksize) - - def blockdev_getsz (self, device): - u"""This returns the size of the device in units of 512-byte - sectors (even if the sectorsize isn't 512 bytes ... - weird). - - See also "g.blockdev_getss" for the real sector size of - the device, and "g.blockdev_getsize64" for the more - useful *size in bytes*. - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_getsz (self._o, device) - - def blockdev_getsize64 (self, device): - u"""This returns the size of the device in bytes. - - See also "g.blockdev_getsz". - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_getsize64 (self._o, device) - - def blockdev_flushbufs (self, device): - u"""This tells the kernel to flush internal buffers - associated with "device". - - This uses the blockdev(8) command. - """ - return libguestfsmod.blockdev_flushbufs (self._o, device) - - def blockdev_rereadpt (self, device): - u"""Reread the partition table on "device". - - This uses the blockdev(8) command. - """ - 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, partnum, 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, partnum, 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) - - def wc_l (self, path): - u"""This command counts the lines in a file, using the "wc - -l" external command. - """ - return libguestfsmod.wc_l (self._o, path) - - def wc_w (self, path): - u"""This command counts the words in a file, using the "wc - -w" external command. - """ - return libguestfsmod.wc_w (self._o, path) - - def wc_c (self, path): - u"""This command counts the characters in a file, using the - "wc -c" external command. - """ - return libguestfsmod.wc_c (self._o, path) - - def head (self, path): - u"""This command returns up to the first 10 lines of a file - as a list of strings. - - 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.head (self._o, path) - - def head_n (self, nrlines, path): - u"""If the parameter "nrlines" is a positive number, this - returns the first "nrlines" lines of the file "path". - - If the parameter "nrlines" is a negative number, this - returns lines from the file "path", excluding the last - "nrlines" lines. - - If the parameter "nrlines" is zero, this returns an - empty list. - - 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.head_n (self._o, nrlines, path) - - def tail (self, path): - u"""This command returns up to the last 10 lines of a file - as a list of strings. - - 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.tail (self._o, path) - - def tail_n (self, nrlines, path): - u"""If the parameter "nrlines" is a positive number, this - returns the last "nrlines" lines of the file "path". - - If the parameter "nrlines" is a negative number, this - returns lines from the file "path", starting with the - "-nrlines"th line. - - If the parameter "nrlines" is zero, this returns an - empty list. - - 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.tail_n (self._o, nrlines, path) - - def df (self): - u"""This command runs the "df" command to report disk space - used. - - This command is mostly useful for interactive sessions. - It is *not* intended that you try to parse the output - string. Use "statvfs" from programs. - """ - return libguestfsmod.df (self._o) - - def df_h (self): - u"""This command runs the "df -h" command to report disk - space used in human-readable format. - - This command is mostly useful for interactive sessions. - It is *not* intended that you try to parse the output - string. Use "statvfs" from programs. - """ - return libguestfsmod.df_h (self._o) - - def du (self, path): - u"""This command runs the "du -s" command to estimate file - space usage for "path". - - "path" can be a file or a directory. If "path" is a - directory then the estimate includes the contents of the - directory and all subdirectories (recursively). - - The result is the estimated size in *kilobytes* (ie. - units of 1024 bytes). - """ - return libguestfsmod.du (self._o, path) - - def initrd_list (self, path): - u"""This command lists out files contained in an initrd. - - The files are listed without any initial "/" character. - The files are listed in the order they appear (not - necessarily alphabetical). Directory names are listed as - separate items. - - Old Linux kernels (2.4 and earlier) used a compressed - ext2 filesystem as initrd. We *only* support the newer - initramfs format (compressed cpio files). - - This function returns a list of strings. - """ - return libguestfsmod.initrd_list (self._o, path) - - def mount_loop (self, file, mountpoint): - u"""This command lets you mount "file" (a filesystem image - in a file) on a mount point. It is entirely equivalent - to the command "mount -o loop file mountpoint". - """ - return libguestfsmod.mount_loop (self._o, file, mountpoint) - - def mkswap (self, device): - u"""Create a swap partition on "device". - """ - return libguestfsmod.mkswap (self._o, device) - - def mkswap_L (self, label, device): - u"""Create a swap partition on "device" with label "label". - """ - return libguestfsmod.mkswap_L (self._o, label, device) - - def mkswap_U (self, uuid, device): - u"""Create a swap partition on "device" with UUID "uuid". - """ - return libguestfsmod.mkswap_U (self._o, uuid, device) - - def mknod (self, mode, devmajor, devminor, path): - u"""This call creates block or character special devices, or - named pipes (FIFOs). - - The "mode" parameter should be the mode, using the - standard constants. "devmajor" and "devminor" are the - device major and minor numbers, only used when creating - block and character special devices. - """ - return libguestfsmod.mknod (self._o, mode, devmajor, devminor, path) - - def mkfifo (self, mode, path): - u"""This call creates a FIFO (named pipe) called "path" with - mode "mode". It is just a convenient wrapper around - "g.mknod". - """ - return libguestfsmod.mkfifo (self._o, mode, path) - - def mknod_b (self, mode, devmajor, devminor, path): - u"""This call creates a block device node called "path" with - mode "mode" and device major/minor "devmajor" and - "devminor". It is just a convenient wrapper around - "g.mknod". - """ - return libguestfsmod.mknod_b (self._o, mode, devmajor, devminor, path) - - def mknod_c (self, mode, devmajor, devminor, path): - u"""This call creates a char device node called "path" with - mode "mode" and device major/minor "devmajor" and - "devminor". It is just a convenient wrapper around - "g.mknod". - """ - return libguestfsmod.mknod_c (self._o, mode, devmajor, devminor, path) - - def umask (self, mask): - u"""This function sets the mask used for creating new files - and device nodes to "mask & 0777". - - Typical umask values would be 022 which creates new - files with permissions like "-rw-r--r--" or - "-rwxr-xr-x", and 002 which creates new files with - permissions like "-rw-rw-r--" or "-rwxrwxr-x". - - The default umask is 022. This is important because it - means that directories and device nodes will be created - with 0644 or 0755 mode even if you specify 0777. - - See also umask(2), "g.mknod", "g.mkdir". - - This call returns the previous umask. - """ - return libguestfsmod.umask (self._o, mask) - - def readdir (self, dir): - u"""This returns the list of directory entries in directory - "dir". - - All entries in the directory are returned, including "." - and "..". The entries are *not* sorted, but returned in - the same order as the underlying filesystem. - - This function is primarily intended for use by programs. - To get a simple list of names, use "g.ls". To get a - printable directory for human consumption, use "g.ll". - - This function returns a list of directory entries. Each - directory entry is represented as a dictionary. - """ - return libguestfsmod.readdir (self._o, dir) -