Map converts one parser to another parser.

All3 requires all three parsers to succeed and it returns a tuple of the parsed objects.

OneOf tries a list of parsers and if one of them succeeds, returns that parser.

Close cleans up internal resources of a Domain and disconnects the underlying qmp.Monitor. Close must be called when done with a Domain to avoid leak

Exactly consumes the exact token from the input stream or fails.

Parse applies the given parser against the input stream.

Run executes the given QMP command against the domain. The returned []byte is the raw output from the QMP monitor. Run should be used with caution, a

NewLibvirtRPCMonitor configures a new Libvirt RPC Monitor connection. The provided domain should be the name of the domain as seen by libvirt, e.g., s

listen listens for incoming data from a QEMU monitor socket. It determines if the data is an asynchronous event or a response to a command, and retur

All2 requires both parsers to succeed and it returns a tuple of the parsed objects.

NewDomain returns a new QEMU domain identified by the given name. QMP communication is handled by the provided monitor socket.

Commit synchronously merges an overlay image onto a block device's root backing image. Once the operation is complete, CompleteJob() must be called to

Connect establishes communication with the libvirt server. The underlying libvirt socket connection must be previously established.

Domains retrieves all virtual machines which reside on a given hypervisor, connecting to the monitor socket of each machine. Each Domain's Close meth

New creates a new Hypervisor using the input Driver.

NewRPCDriver configures a hypervisor driver using Libvirt RPC. The provided newConn function should return an established network connection with the

waitForSignal opens a domain's QMP event stream and invokes an input closure to send commands which would create results on that event stream.

BlockDevices returns a domain's block devices.

Commands returns all QMP commands supported by the domain.

Complete a running block job. For blockcommit backups, this performs the "pivot" back to the original backing image.

Disconnect shuts down communication with the libvirt server and closes the underlying net.Conn.

Domain retrieves a single virtual machine from a hypervisor, connecting to its monitor socket. If no virtual machine exists with the given name, an e

NewMonitor creates a qmp.Monitor that invokes runFunc whenever its Run method is called. All other methods are a no-op, and return nil.

Nothing is a parser that always succeeds and doesn't consume input.

Status returns the current status of the domain.

getQAPI reads a QMP API spec file, from local disk or over HTTP(S).

BlockDevice searches a domain for the given block device. If found, a BlockDevice is returned. If the device is not found, the returned error will be

Events streams QEMU QMP events. Two channels are returned, the first contains events emitted by the domain. The second is used to signal completion of

Lex lexes the input document into tokens.

ManyOf attempts to successfully parse 0 or more times.

Mirror copies a block device to the given destination. The destination path specified by dest must be absolute.

PCIDevices returns a domain's PCI devices.

Supported returns true if the provided command is supported by the domain.

SystemPowerdown sends a system power down event to the domain.

Version returns the domain's QEMU version.

completeParseTree walks the parse tree and expands the Include statements. It returns the completely resolved parse tree.

connectDomain opens a monitor socket connection and creates a virtual machine for the machine with the specified name.

lowerParseTree converts the parsed types from package qapischema into types that are wired up for Go code generation.

neededTypes returns the subset of API that should be rendered to file. The subset to render is defined as the transitive closure of all types reachab

qmpEvent takes a libvirt DomainEvent and returns the QMP equivalent.

renderAPI generates the Go implementation for the types listed in need.

withLibvirt opens a new RPC connection to Libvirt and invokes the input closure using the RPC connection. Connections are automatically cleaned up wh

BlockJobs returns active block job operations.

BlockStats returns block device statistics for a domain.

CPUs returns a domain's CPUs.

Cancel a running block job. For block-mirror operations, this cancels the block job.

Connect sets up a QEMU QMP connection by connecting directly to the QEMU monitor socket. An error is returned if the capabilities handshake does not

ConsumeAtLeastOne attempts to parse at least once with the given parser and then continues until it fails to parse.

Disconnect closes the QEMU monitor socket connection.

DomainNames retrieves all hypervisor domain names using libvirt RPC.

Events streams QEMU QMP Events until the provided context is cancelled. If a problem is encountered setting up the event monitor connection an error w

Listen creates a new SocketMonitor listening for a single connection to the provided socket file or address. An error is returned if unable to listen

MarshalJSON implements json.Marshaler.

MatchesToken consumes the token from the input stream if matcher returns true.

NewMonitor wraps a qmp.Monitor into a raw.Monitor.

NewSocketMonitor configures a connection to the provided QEMU monitor socket. An error is returned if the socket cannot be successfully dialed, or the

PackageVersion returns the domain's QEMU package version, the full build information for QEMU.

query-commands -> QueryCommands (command) QueryCommands implements the "query-commands" QMP API call.

query-status -> QueryStatus (command) QueryStatus implements the "query-status" QMP API call.

query-version -> QueryVersion (command) QueryVersion implements the "query-version" QMP API call.

Run executes the given QAPI command against a domain's QEMU instance. For a list of available QAPI commands, see: http://git.qemu.org/?p=qemu.git;a=b

RunWithFile behaves like Run but allows for passing a file through out-of-band data.

ScreenDump captures the domain's screen and creates an output PPM image stream. ScreenDump will only work if the Domain resides on a local hypervisor

Snapshot creates a point in time snapshot. The disk's image is given a new QCOW2 overlay, leaving the underlying image in a state that is considered s

SystemReset sends a system reset event to the domain.