X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=python%2Fguestfs.py;h=23aef9c280a0cb62fc05e5f2e456cb5829d04d82;hp=77c29895bb748e227e7854d5f25ce9f0181ec293;hb=215041c7178922341ecbfdb23eb203f2bb8c29c4;hpb=ca49c50e06834bbc68e21630a5552c57494f2b53 diff --git a/python/guestfs.py b/python/guestfs.py index 77c2989..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 @@ -832,7 +947,9 @@ 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. @@ -862,6 +979,8 @@ 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 @@ -1223,6 +1342,8 @@ class GuestFS: *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) @@ -1433,6 +1554,176 @@ class GuestFS: 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) +