guestfs-golang3

Usage

 import "libguestfs.org/guestfs"
 
 g, errno := guestfs.Create ()
 if errno != nil {
     panic (fmt.Sprintf ("could not create handle: %s", errno))
 }
 defer g.Close ()
 if err := g.Add_drive ("test.img"); err != nil {
     panic (err)
 }
 if err := g.Launch (); err != nil {
     panic (err)
 }
 if err := g.Shutdown (); err != nil {
     panic (err)
 }

Overview

This manual page documents how to call libguestfs from the Go programming language. This page just documents the differences from the C API and gives some examples. If you are not familiar with using libguestfs, you also need to read guestfs(3).

Example 1: create a disk image

 /* Example showing how to create a disk image. */
 
 package main
 
 import (
        "fmt"
        "libguestfs.org/guestfs"
 )
 
 func main() {
        output := "disk.img"
 
        g, errno := guestfs.Create ()
        if errno != nil {
                panic (errno)
        }
        defer g.Close ()
 
        /* Create a raw-format sparse disk image, 512 MB in size. */
        if err := g.Disk_create (output, "raw", 512 * 1024 * 1024); err != nil {
                panic (err)
        }
 
        /* Set the trace flag so that we can see each libguestfs call. */
        g.Set_trace (true)
 
        /* Attach the disk image to libguestfs. */
        optargs := guestfs.OptargsAdd_drive{
                Format_is_set: true,
                Format: "raw",
                Readonly_is_set: true,
                Readonly: false,
        }
        if err := g.Add_drive (output, &optargs); err != nil {
                panic (err)
        }
 
        /* Run the libguestfs back-end. */
        if err := g.Launch (); err != nil {
                panic (err)
        }
 
        /* Get the list of devices.  Because we only added one drive
         * above, we expect that this list should contain a single
         * element.
         */
        devices, err := g.List_devices ()
        if err != nil {
                panic (err)
        }
        if len(devices) != 1 {
                panic ("expected a single device from list-devices")
        }
 
        /* Partition the disk as one single MBR partition. */
        err = g.Part_disk (devices[0], "mbr")
        if err != nil {
                panic (err)
        }
 
        /* Get the list of partitions.  We expect a single element, which
         * is the partition we have just created.
         */
        partitions, err := g.List_partitions ()
        if err != nil {
                panic (err)
        }
        if len(partitions) != 1 {
                panic ("expected a single partition from list-partitions")
        }
 
        /* Create a filesystem on the partition. */
        err = g.Mkfs ("ext4", partitions[0], nil)
        if err != nil {
                panic (err)
        }
 
        /* Now mount the filesystem so that we can add files. */
        err = g.Mount (partitions[0], "/")
        if err != nil {
                panic (err)
        }
 
        /* Create some files and directories. */
        err = g.Touch ("/empty")
        if err != nil {
                panic (err)
        }
        message := []byte("Hello, world\n")
        err = g.Write ("/hello", message)
        if err != nil {
                panic (err)
        }
        err = g.Mkdir ("/foo")
        if err != nil {
                panic (err)
        }
 
        /* This one uploads the local file /etc/resolv.conf into
         * the disk image.
         */
        err = g.Upload ("/etc/resolv.conf", "/foo/resolv.conf")
        if err != nil {
                panic (err)
        }
 
        /* Because we wrote to the disk and we want to detect write
         * errors, call g:shutdown.  You don't need to do this:
         * g.Close will do it implicitly.
         */
        if err = g.Shutdown (); err != nil {
                panic (fmt.Sprintf ("write to disk failed: %s", err))
        }
 }

Example 2: inspect a virtual machine disk image

 /* Example showing how to inspect a virtual machine disk. */
 
 package main
 
 import (
        "fmt"
        "os"
        "libguestfs.org/guestfs"
 )
 
 func main() {
        if len(os.Args) < 2 {
                panic ("usage: inspect-vm disk.img")
        }
        disk := os.Args[1]
 
        g, errno := guestfs.Create ()
        if errno != nil {
                panic (fmt.Sprintf ("could not create handle: %s", errno))
        }
 
        /* Attach the disk image read-only to libguestfs. */
        optargs := guestfs.OptargsAdd_drive{
                Format_is_set: true,
                Format: "raw",
                Readonly_is_set: true,
                Readonly: true,
        }
        if err := g.Add_drive (disk, &optargs); err != nil {
                panic (err)
        }
 
        /* Run the libguestfs back-end. */
        if err := g.Launch (); err != nil {
                panic (err)
        }
 
        /* Ask libguestfs to inspect for operating systems. */
        roots, err := g.Inspect_os ()
        if err != nil {
                panic (err)
        }
        if len(roots) == 0 {
                panic ("inspect-vm: no operating systems found")
        }
 
        for _, root := range roots {
                fmt.Printf ("Root device: %s\n", root)
 
                /* Print basic information about the operating system. */
                s, _ := g.Inspect_get_product_name (root)
                fmt.Printf ("  Product name: %s\n", s)
                major, _ := g.Inspect_get_major_version (root)
                minor, _ := g.Inspect_get_minor_version (root)
                fmt.Printf ("  Version:      %d.%d\n", major, minor)
                s, _ = g.Inspect_get_type (root)
                fmt.Printf ("  Type:         %s\n", s)
                s, _ = g.Inspect_get_distro (root)
                fmt.Printf ("  Distro:       %s\n", s)
 
                /* XXX Incomplete example.  Sorting the keys by length
                 * is unnecessarily hard in golang.
                 */
        }
 }