libvirt-go-xml: github.com/libvirt/libvirt-go-xml Index | Files

package libvirtxml

import "github.com/libvirt/libvirt-go-xml"

Package libvirt-go-xml defines structs for parsing libvirt XML schemas

The libvirt API uses XML schemas/documents to describe the configuration of many of its managed objects. Thus when using the libvirt-go package, it is often neccessary to either parse or format XML documents. This package defines a set of Go structs which have been annotated for use with the encoding/xml API to manage libvirt XML documents.

Example creating a domain XML document from configuration:

import (
 "github.com/libvirt/libvirt-go-xml"
)

domcfg := &libvirtxml.Domain{Type: "kvm", Name: "demo",
                             UUID: "8f99e332-06c4-463a-9099-330fb244e1b3",
                             ....}
xmldoc, err := domcfg.Marshal()

Example parsing a domainXML document, in combination with libvirt-go

import (
  "github.com/libvirt/libvirt-go"
  "github.com/libvirt/libvirt-go-xml"
  "fmt"
)

conn, err := libvirt.NewConnect("qemu:///system")
dom := conn.LookupDomainByName("demo")
xmldoc, err := dom.GetXMLDesc(0)

domcfg := &libvirtxml.Domain{}
err := domcfg.Unmarshal(xmldoc)

fmt.Printf("Virt type %s", domcfg.Type)

Index

Package Files

capabilities.go doc.go document.go domain.go domain_capabilities.go domain_snapshot.go interface.go network.go node_device.go nwfilter.go secret.go storage_encryption.go storage_pool.go storage_vol.go xmlutil.go

type Caps Uses

type Caps struct {
    XMLName xml.Name    `xml:"capabilities"`
    Host    CapsHost    `xml:"host"`
    Guests  []CapsGuest `xml:"guest"`
}

func (*Caps) Marshal Uses

func (c *Caps) Marshal() (string, error)

func (*Caps) Unmarshal Uses

func (c *Caps) Unmarshal(doc string) error

type CapsGuest Uses

type CapsGuest struct {
    OSType   string             `xml:"os_type"`
    Arch     CapsGuestArch      `xml:"arch"`
    Features *CapsGuestFeatures `xml:"features"`
}

type CapsGuestArch Uses

type CapsGuestArch struct {
    Name     string             `xml:"name,attr"`
    WordSize string             `xml:"wordsize"`
    Emulator string             `xml:"emulator"`
    Loader   string             `xml:"loader,omitempty"`
    Machines []CapsGuestMachine `xml:"machine"`
    Domains  []CapsGuestDomain  `xml:"domain"`
}

type CapsGuestDomain Uses

type CapsGuestDomain struct {
    Type     string             `xml:"type,attr"`
    Emulator string             `xml:"emulator,omitempty"`
    Machines []CapsGuestMachine `xml:"machine"`
}

type CapsGuestFeatureACPI Uses

type CapsGuestFeatureACPI struct {
    Default string `xml:"default,attr,omitempty"`
    Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureAPIC Uses

type CapsGuestFeatureAPIC struct {
    Default string `xml:"default,attr,omitempty"`
    Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureCPUSelection Uses

type CapsGuestFeatureCPUSelection struct {
}

type CapsGuestFeatureDeviceBoot Uses

type CapsGuestFeatureDeviceBoot struct {
}

type CapsGuestFeatureDiskSnapshot Uses

type CapsGuestFeatureDiskSnapshot struct {
    Default string `xml:"default,attr,omitempty"`
    Toggle  string `xml:"toggle,attr,omitempty"`
}

type CapsGuestFeatureIA64BE Uses

type CapsGuestFeatureIA64BE struct {
}

type CapsGuestFeatureNonPAE Uses

type CapsGuestFeatureNonPAE struct {
}

type CapsGuestFeaturePAE Uses

type CapsGuestFeaturePAE struct {
}

type CapsGuestFeatures Uses

type CapsGuestFeatures struct {
    CPUSelection *CapsGuestFeatureCPUSelection `xml:"cpuselection"`
    DeviceBoot   *CapsGuestFeatureDeviceBoot   `xml:"deviceboot"`
    DiskSnapshot *CapsGuestFeatureDiskSnapshot `xml:"disksnapshot"`
    PAE          *CapsGuestFeaturePAE          `xml:"pae"`
    NonPAE       *CapsGuestFeatureNonPAE       `xml:"nonpae"`
    APIC         *CapsGuestFeatureAPIC         `xml:"apic"`
    ACPI         *CapsGuestFeatureACPI         `xml:"acpi"`
    IA64BE       *CapsGuestFeatureIA64BE       `xml:"ia64_be"`
}

type CapsGuestMachine Uses

type CapsGuestMachine struct {
    Name      string `xml:",chardata"`
    MaxCPUs   int    `xml:"maxCpus,attr,omitempty"`
    Canonical string `xml:"canonical,attr,omitempty"`
}

type CapsHost Uses

type CapsHost struct {
    UUID              string                     `xml:"uuid,omitempty"`
    CPU               *CapsHostCPU               `xml:"cpu"`
    PowerManagement   *CapsHostPowerManagement   `xml:"power_management"`
    MigrationFeatures *CapsHostMigrationFeatures `xml:"migration_features"`
    NUMA              *CapsHostNUMATopology      `xml:"topology"`
    Cache             *CapsHostCache             `xml:"cache"`
    SecModel          []CapsHostSecModel         `xml:"secmodel"`
}

type CapsHostCPU Uses

type CapsHostCPU struct {
    XMLName      xml.Name                 `xml:"cpu"`
    Arch         string                   `xml:"arch,omitempty"`
    Model        string                   `xml:"model,omitempty"`
    Vendor       string                   `xml:"vendor,omitempty"`
    Topology     *CapsHostCPUTopology     `xml:"topology"`
    FeatureFlags []CapsHostCPUFeatureFlag `xml:"feature"`
    Features     *CapsHostCPUFeatures     `xml:"features"`
    PageSizes    []CapsHostCPUPageSize    `xml:"pages"`
}

func (*CapsHostCPU) Marshal Uses

func (c *CapsHostCPU) Marshal() (string, error)

func (*CapsHostCPU) Unmarshal Uses

func (c *CapsHostCPU) Unmarshal(doc string) error

type CapsHostCPUFeature Uses

type CapsHostCPUFeature struct {
}

type CapsHostCPUFeatureFlag Uses

type CapsHostCPUFeatureFlag struct {
    Name string `xml:"name,attr"`
}

type CapsHostCPUFeatures Uses

type CapsHostCPUFeatures struct {
    PAE    *CapsHostCPUFeature `xml:"pae"`
    NonPAE *CapsHostCPUFeature `xml:"nonpae"`
    SVM    *CapsHostCPUFeature `xml:"svm"`
    VMX    *CapsHostCPUFeature `xml:"vmx"`
}

type CapsHostCPUPageSize Uses

type CapsHostCPUPageSize struct {
    Size int    `xml:"size,attr"`
    Unit string `xml:"unit,attr"`
}

type CapsHostCPUTopology Uses

type CapsHostCPUTopology struct {
    Sockets int `xml:"sockets,attr"`
    Cores   int `xml:"cores,attr"`
    Threads int `xml:"threads,attr"`
}

type CapsHostCache Uses

type CapsHostCache struct {
    Banks []CapsHostCacheBank `xml:"bank"`
}

type CapsHostCacheBank Uses

type CapsHostCacheBank struct {
    ID      uint                   `xml:"id,attr"`
    Level   uint                   `xml:"level,attr"`
    Type    string                 `xml:"type,attr"`
    Size    uint                   `xml:"size,attr"`
    Unit    string                 `xml:"unit,attr"`
    CPUs    string                 `xml:"cpus,attr"`
    Control []CapsHostCacheControl `xml:"control"`
}

type CapsHostCacheControl Uses

type CapsHostCacheControl struct {
    Granularity uint   `xml:"granularity,attr"`
    Min         uint   `xml:"min,attr,omitempty"`
    Unit        string `xml:"unit,attr"`
    Type        string `xml:"type,attr"`
    MaxAllows   uint   `xml:"maxAllocs,attr"`
}

type CapsHostMigrationFeatures Uses

type CapsHostMigrationFeatures struct {
    Live          *CapsHostMigrationLive          `xml:"live"`
    URITransports *CapsHostMigrationURITransports `xml:"uri_transports"`
}

type CapsHostMigrationLive Uses

type CapsHostMigrationLive struct {
}

type CapsHostMigrationURITransports Uses

type CapsHostMigrationURITransports struct {
    URI []string `xml:"uri_transport"`
}

type CapsHostNUMACPU Uses

type CapsHostNUMACPU struct {
    ID       int    `xml:"id,attr"`
    SocketID *int   `xml:"socket_id,attr"`
    CoreID   *int   `xml:"core_id,attr"`
    Siblings string `xml:"siblings,attr,omitempty"`
}

type CapsHostNUMACPUs Uses

type CapsHostNUMACPUs struct {
    Num  uint              `xml:"num,attr,omitempty"`
    CPUs []CapsHostNUMACPU `xml:"cpu"`
}

type CapsHostNUMACell Uses

type CapsHostNUMACell struct {
    ID        int                    `xml:"id,attr"`
    Memory    *CapsHostNUMAMemory    `xml:"memory"`
    PageInfo  []CapsHostNUMAPageInfo `xml:"pages"`
    Distances *CapsHostNUMADistances `xml:"distances"`
    CPUS      *CapsHostNUMACPUs      `xml:"cpus"`
}

type CapsHostNUMACells Uses

type CapsHostNUMACells struct {
    Num   uint               `xml:"num,attr,omitempty"`
    Cells []CapsHostNUMACell `xml:"cell"`
}

type CapsHostNUMADistances Uses

type CapsHostNUMADistances struct {
    Siblings []CapsHostNUMASibling `xml:"sibling"`
}

type CapsHostNUMAMemory Uses

type CapsHostNUMAMemory struct {
    Size uint64 `xml:",chardata"`
    Unit string `xml:"unit,attr"`
}

type CapsHostNUMAPageInfo Uses

type CapsHostNUMAPageInfo struct {
    Size  int    `xml:"size,attr"`
    Unit  string `xml:"unit,attr"`
    Count uint64 `xml:",chardata"`
}

type CapsHostNUMASibling Uses

type CapsHostNUMASibling struct {
    ID    int `xml:"id,attr"`
    Value int `xml:"value,attr"`
}

type CapsHostNUMATopology Uses

type CapsHostNUMATopology struct {
    Cells *CapsHostNUMACells `xml:"cells"`
}

type CapsHostPowerManagement Uses

type CapsHostPowerManagement struct {
    SuspendMem    *CapsHostPowerManagementMode `xml:"suspend_mem"`
    SuspendDisk   *CapsHostPowerManagementMode `xml:"suspend_disk"`
    SuspendHybrid *CapsHostPowerManagementMode `xml:"suspend_hybrid"`
}

type CapsHostPowerManagementMode Uses

type CapsHostPowerManagementMode struct {
}

type CapsHostSecModel Uses

type CapsHostSecModel struct {
    Name   string                  `xml:"model"`
    DOI    string                  `xml:"doi"`
    Labels []CapsHostSecModelLabel `xml:"baselabel"`
}

type CapsHostSecModelLabel Uses

type CapsHostSecModelLabel struct {
    Type  string `xml:"type,attr"`
    Value string `xml:",chardata"`
}

type Document Uses

type Document interface {
    Unmarshal(doc string) error
    Marshal() (string, error)
}

type Domain Uses

type Domain struct {
    XMLName              xml.Name             `xml:"domain"`
    Type                 string               `xml:"type,attr,omitempty"`
    ID                   *int                 `xml:"id,attr"`
    Name                 string               `xml:"name,omitempty"`
    UUID                 string               `xml:"uuid,omitempty"`
    Title                string               `xml:"title,omitempty"`
    Description          string               `xml:"description,omitempty"`
    Metadata             *DomainMetadata      `xml:"metadata"`
    MaximumMemory        *DomainMaxMemory     `xml:"maxMemory"`
    Memory               *DomainMemory        `xml:"memory"`
    CurrentMemory        *DomainCurrentMemory `xml:"currentMemory"`
    BlockIOTune          *DomainBlockIOTune   `xml:"blkiotune"`
    MemoryTune           *DomainMemoryTune    `xml:"memtune"`
    MemoryBacking        *DomainMemoryBacking `xml:"memoryBacking"`
    VCPU                 *DomainVCPU          `xml:"vcpu"`
    VCPUs                *DomainVCPUs         `xml:"vcpus"`
    IOThreads            uint                 `xml:"iothreads,omitempty"`
    IOThreadIDs          *DomainIOThreadIDs   `xml:"iothreadids"`
    CPUTune              *DomainCPUTune       `xml:"cputune"`
    NUMATune             *DomainNUMATune      `xml:"numatune"`
    Resource             *DomainResource      `xml:"resource"`
    SysInfo              *DomainSysInfo       `xml:"sysinfo"`
    Bootloader           string               `xml:"bootloader,omitempty"`
    BootloaderArgs       string               `xml:"bootloader_args,omitempty"`
    OS                   *DomainOS            `xml:"os"`
    IDMap                *DomainIDMap         `xml:"idmap"`
    Features             *DomainFeatureList   `xml:"features"`
    CPU                  *DomainCPU           `xml:"cpu"`
    Clock                *DomainClock         `xml:"clock"`
    OnPoweroff           string               `xml:"on_poweroff,omitempty"`
    OnReboot             string               `xml:"on_reboot,omitempty"`
    OnCrash              string               `xml:"on_crash,omitempty"`
    PM                   *DomainPM            `xml:"pm"`
    Perf                 *DomainPerf          `xml:"perf"`
    Devices              *DomainDeviceList    `xml:"devices"`
    SecLabel             []DomainSecLabel     `xml:"seclabel"`
    QEMUCommandline      *DomainQEMUCommandline
    LXCNamespace         *DomainLXCNamespace
    VMWareDataCenterPath *DomainVMWareDataCenterPath
    KeyWrap              *DomainKeyWrap `xml:"keywrap"`
}

NB, try to keep the order of fields in this struct matching the order of XML elements that libvirt will generate when dumping XML.

func (*Domain) Marshal Uses

func (d *Domain) Marshal() (string, error)

func (*Domain) Unmarshal Uses

func (d *Domain) Unmarshal(doc string) error

type DomainACPI Uses

type DomainACPI struct {
    Tables []DomainACPITable `xml:"table"`
}

type DomainACPITable Uses

type DomainACPITable struct {
    Type string `xml:"type,attr"`
    Path string `xml:",chardata"`
}

type DomainAddress Uses

type DomainAddress struct {
    PCI          *DomainAddressPCI
    Drive        *DomainAddressDrive
    VirtioSerial *DomainAddressVirtioSerial
    CCID         *DomainAddressCCID
    USB          *DomainAddressUSB
    SpaprVIO     *DomainAddressSpaprVIO
    VirtioS390   *DomainAddressVirtioS390
    CCW          *DomainAddressCCW
    VirtioMMIO   *DomainAddressVirtioMMIO
    ISA          *DomainAddressISA
    DIMM         *DomainAddressDIMM
}

func (*DomainAddress) MarshalXML Uses

func (a *DomainAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddress) UnmarshalXML Uses

func (a *DomainAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressCCID Uses

type DomainAddressCCID struct {
    Controller *uint `xml:"controller,attr"`
    Slot       *uint `xml:"slot,attr"`
}

func (*DomainAddressCCID) MarshalXML Uses

func (a *DomainAddressCCID) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressCCID) UnmarshalXML Uses

func (a *DomainAddressCCID) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressCCW Uses

type DomainAddressCCW struct {
    CSSID *uint `xml:"cssid,attr"`
    SSID  *uint `xml:"ssid,attr"`
    DevNo *uint `xml:"devno,attr"`
}

func (*DomainAddressCCW) MarshalXML Uses

func (a *DomainAddressCCW) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressCCW) UnmarshalXML Uses

func (a *DomainAddressCCW) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressDIMM Uses

type DomainAddressDIMM struct {
    Slot *uint   `xml:"slot,attr"`
    Base *uint64 `xml:"base,attr"`
}

func (*DomainAddressDIMM) MarshalXML Uses

func (a *DomainAddressDIMM) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressDIMM) UnmarshalXML Uses

func (a *DomainAddressDIMM) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressDrive Uses

type DomainAddressDrive struct {
    Controller *uint `xml:"controller,attr"`
    Bus        *uint `xml:"bus,attr"`
    Target     *uint `xml:"target,attr"`
    Unit       *uint `xml:"unit,attr"`
}

func (*DomainAddressDrive) MarshalXML Uses

func (a *DomainAddressDrive) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressDrive) UnmarshalXML Uses

func (a *DomainAddressDrive) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressISA Uses

type DomainAddressISA struct {
    IOBase *uint `xml:"iobase,attr"`
    IRQ    *uint `xml:"irq,attr"`
}

func (*DomainAddressISA) MarshalXML Uses

func (a *DomainAddressISA) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressISA) UnmarshalXML Uses

func (a *DomainAddressISA) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressMDev Uses

type DomainAddressMDev struct {
    UUID string `xml:"uuid,attr"`
}

type DomainAddressPCI Uses

type DomainAddressPCI struct {
    Domain        *uint  `xml:"domain,attr"`
    Bus           *uint  `xml:"bus,attr"`
    Slot          *uint  `xml:"slot,attr"`
    Function      *uint  `xml:"function,attr"`
    MultiFunction string `xml:"multifunction,attr,omitempty"`
}

func (*DomainAddressPCI) MarshalXML Uses

func (a *DomainAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressPCI) UnmarshalXML Uses

func (a *DomainAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressSpaprVIO Uses

type DomainAddressSpaprVIO struct {
    Reg *uint64 `xml:"reg,attr"`
}

func (*DomainAddressSpaprVIO) MarshalXML Uses

func (a *DomainAddressSpaprVIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressSpaprVIO) UnmarshalXML Uses

func (a *DomainAddressSpaprVIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressUSB Uses

type DomainAddressUSB struct {
    Bus    *uint  `xml:"bus,attr"`
    Port   string `xml:"port,attr,omitempty"`
    Device *uint  `xml:"device,attr"`
}

func (*DomainAddressUSB) MarshalXML Uses

func (a *DomainAddressUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressUSB) UnmarshalXML Uses

func (a *DomainAddressUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioMMIO Uses

type DomainAddressVirtioMMIO struct {
}

func (*DomainAddressVirtioMMIO) MarshalXML Uses

func (a *DomainAddressVirtioMMIO) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioMMIO) UnmarshalXML Uses

func (a *DomainAddressVirtioMMIO) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioS390 Uses

type DomainAddressVirtioS390 struct {
}

func (*DomainAddressVirtioS390) MarshalXML Uses

func (a *DomainAddressVirtioS390) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioS390) UnmarshalXML Uses

func (a *DomainAddressVirtioS390) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAddressVirtioSerial Uses

type DomainAddressVirtioSerial struct {
    Controller *uint `xml:"controller,attr"`
    Bus        *uint `xml:"bus,attr"`
    Port       *uint `xml:"port,attr"`
}

func (*DomainAddressVirtioSerial) MarshalXML Uses

func (a *DomainAddressVirtioSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainAddressVirtioSerial) UnmarshalXML Uses

func (a *DomainAddressVirtioSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainAlias Uses

type DomainAlias struct {
    Name string `xml:"name,attr"`
}

type DomainBIOS Uses

type DomainBIOS struct {
    UseSerial     string `xml:"useserial,attr,omitempty"`
    RebootTimeout *int   `xml:"rebootTimeout,attr"`
}

type DomainBlockIOTune Uses

type DomainBlockIOTune struct {
    Weight uint                      `xml:"weight,omitempty"`
    Device []DomainBlockIOTuneDevice `xml:"device"`
}

type DomainBlockIOTuneDevice Uses

type DomainBlockIOTuneDevice struct {
    Path          string `xml:"path"`
    Weight        uint   `xml:"weight,omitempty"`
    ReadIopsSec   uint   `xml:"read_iops_sec,omitempty"`
    WriteIopsSec  uint   `xml:"write_iops_sec,omitempty"`
    ReadBytesSec  uint   `xml:"read_bytes_sec,omitempty"`
    WriteBytesSec uint   `xml:"write_bytes_sec,omitempty"`
}

type DomainBootDevice Uses

type DomainBootDevice struct {
    Dev string `xml:"dev,attr"`
}

type DomainBootMenu Uses

type DomainBootMenu struct {
    Enable  string `xml:"enable,attr,omitempty"`
    Timeout string `xml:"timeout,attr,omitempty"`
}

type DomainCPU Uses

type DomainCPU struct {
    XMLName  xml.Name           `xml:"cpu"`
    Match    string             `xml:"match,attr,omitempty"`
    Mode     string             `xml:"mode,attr,omitempty"`
    Check    string             `xml:"check,attr,omitempty"`
    Model    *DomainCPUModel    `xml:"model"`
    Vendor   string             `xml:"vendor,omitempty"`
    Topology *DomainCPUTopology `xml:"topology"`
    Cache    *DomainCPUCache    `xml:"cache"`
    Features []DomainCPUFeature `xml:"feature"`
    Numa     *DomainNuma        `xml:"numa"`
}

func (*DomainCPU) Marshal Uses

func (d *DomainCPU) Marshal() (string, error)

func (*DomainCPU) Unmarshal Uses

func (d *DomainCPU) Unmarshal(doc string) error

type DomainCPUCache Uses

type DomainCPUCache struct {
    Level uint   `xml:"level,attr,omitempty"`
    Mode  string `xml:"mode,attr"`
}

type DomainCPUFeature Uses

type DomainCPUFeature struct {
    Policy string `xml:"policy,attr,omitempty"`
    Name   string `xml:"name,attr,omitempty"`
}

type DomainCPUModel Uses

type DomainCPUModel struct {
    Fallback string `xml:"fallback,attr,omitempty"`
    Value    string `xml:",chardata"`
    VendorID string `xml:"vendor_id,attr,omitempty"`
}

type DomainCPUTopology Uses

type DomainCPUTopology struct {
    Sockets int `xml:"sockets,attr,omitempty"`
    Cores   int `xml:"cores,attr,omitempty"`
    Threads int `xml:"threads,attr,omitempty"`
}

type DomainCPUTune Uses

type DomainCPUTune struct {
    Shares         *DomainCPUTuneShares         `xml:"shares"`
    Period         *DomainCPUTunePeriod         `xml:"period"`
    Quota          *DomainCPUTuneQuota          `xml:"quota"`
    GlobalPeriod   *DomainCPUTunePeriod         `xml:"global_period"`
    GlobalQuota    *DomainCPUTuneQuota          `xml:"global_quota"`
    EmulatorPeriod *DomainCPUTunePeriod         `xml:"emulator_period"`
    EmulatorQuota  *DomainCPUTuneQuota          `xml:"emulator_quota"`
    IOThreadPeriod *DomainCPUTunePeriod         `xml:"iothread_period"`
    IOThreadQuota  *DomainCPUTuneQuota          `xml:"iothread_quota"`
    VCPUPin        []DomainCPUTuneVCPUPin       `xml:"vcpupin"`
    EmulatorPin    *DomainCPUTuneEmulatorPin    `xml:"emulatorpin"`
    IOThreadPin    []DomainCPUTuneIOThreadPin   `xml:"iothreadpin"`
    VCPUSched      []DomainCPUTuneVCPUSched     `xml:"vcpusched"`
    IOThreadSched  []DomainCPUTuneIOThreadSched `xml:"iothreadsched"`
}

type DomainCPUTuneEmulatorPin Uses

type DomainCPUTuneEmulatorPin struct {
    CPUSet string `xml:"cpuset,attr"`
}

type DomainCPUTuneIOThreadPin Uses

type DomainCPUTuneIOThreadPin struct {
    IOThread uint   `xml:"iothread,attr"`
    CPUSet   string `xml:"cpuset,attr"`
}

type DomainCPUTuneIOThreadSched Uses

type DomainCPUTuneIOThreadSched struct {
    IOThreads string `xml:"iothreads,attr"`
    Scheduler string `xml:"scheduler,attr,omitempty"`
    Priority  *int   `xml:"priority,attr"`
}

type DomainCPUTunePeriod Uses

type DomainCPUTunePeriod struct {
    Value uint64 `xml:",chardata"`
}

type DomainCPUTuneQuota Uses

type DomainCPUTuneQuota struct {
    Value int64 `xml:",chardata"`
}

type DomainCPUTuneShares Uses

type DomainCPUTuneShares struct {
    Value uint `xml:",chardata"`
}

type DomainCPUTuneVCPUPin Uses

type DomainCPUTuneVCPUPin struct {
    VCPU   uint   `xml:"vcpu,attr"`
    CPUSet string `xml:"cpuset,attr"`
}

type DomainCPUTuneVCPUSched Uses

type DomainCPUTuneVCPUSched struct {
    VCPUs     string `xml:"vcpus,attr"`
    Scheduler string `xml:"scheduler,attr,omitempty"`
    Priority  *int   `xml:"priority,attr"`
}

type DomainCaps Uses

type DomainCaps struct {
    XMLName  xml.Name            `xml:"domainCapabilities"`
    Path     string              `xml:"path"`
    Domain   string              `xml:"domain"`
    Machine  string              `xml:"machine,omitempty"`
    Arch     string              `xml:"arch"`
    VCPU     *DomainCapsVCPU     `xml:"vcpu"`
    OS       DomainCapsOS        `xml:"os"`
    CPU      *DomainCapsCPU      `xml:"cpu"`
    Devices  *DomainCapsDevices  `xml:"devices"`
    Features *DomainCapsFeatures `xml:"features"`
}

func (*DomainCaps) Marshal Uses

func (c *DomainCaps) Marshal() (string, error)

func (*DomainCaps) Unmarshal Uses

func (c *DomainCaps) Unmarshal(doc string) error

type DomainCapsCPU Uses

type DomainCapsCPU struct {
    Modes []DomainCapsCPUMode `xml:"mode"`
}

type DomainCapsCPUFeature Uses

type DomainCapsCPUFeature struct {
    Policy string `xml:"policy,attr,omitempty"`
    Name   string `xml:"name,attr"`
}

type DomainCapsCPUMode Uses

type DomainCapsCPUMode struct {
    Name      string                 `xml:"name,attr"`
    Supported string                 `xml:"supported,attr"`
    Models    []DomainCapsCPUModel   `xml:"model"`
    Vendor    string                 `xml:"vendor,omitempty"`
    Features  []DomainCapsCPUFeature `xml:"feature"`
}

type DomainCapsCPUModel Uses

type DomainCapsCPUModel struct {
    Name     string `xml:",chardata"`
    Usable   string `xml:"usable,attr,omitempty"`
    Fallback string `xml:"fallback,attr,omitempty"`
}

type DomainCapsDevice Uses

type DomainCapsDevice struct {
    Supported string           `xml:"supported,attr"`
    Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsDevices Uses

type DomainCapsDevices struct {
    Disk     *DomainCapsDevice `xml:"disk"`
    Graphics *DomainCapsDevice `xml:"graphics"`
    Video    *DomainCapsDevice `xml:"video"`
    HostDev  *DomainCapsDevice `xml:"hostdev"`
}

type DomainCapsEnum Uses

type DomainCapsEnum struct {
    Name   string   `xml:"name,attr"`
    Values []string `xml:"value"`
}

type DomainCapsFeatureGIC Uses

type DomainCapsFeatureGIC struct {
    Supported string           `xml:"supported,attr"`
    Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsFeatures Uses

type DomainCapsFeatures struct {
    GIC *DomainCapsFeatureGIC `xml:"gic"`
}

type DomainCapsOS Uses

type DomainCapsOS struct {
    Supported string              `xml:"supported,attr"`
    Loader    *DomainCapsOSLoader `xml:"loader"`
}

type DomainCapsOSLoader Uses

type DomainCapsOSLoader struct {
    Supported string           `xml:"supported,attr"`
    Values    []string         `xml:"value"`
    Enums     []DomainCapsEnum `xml:"enum"`
}

type DomainCapsVCPU Uses

type DomainCapsVCPU struct {
    Max uint `xml:"max,attr"`
}

type DomainCell Uses

type DomainCell struct {
    ID        *uint                `xml:"id,attr"`
    CPUs      string               `xml:"cpus,attr"`
    Memory    string               `xml:"memory,attr"`
    Unit      string               `xml:"unit,attr,omitempty"`
    MemAccess string               `xml:"memAccess,attr,omitempty"`
    Distances *DomainCellDistances `xml:"distances"`
}

type DomainCellDistances Uses

type DomainCellDistances struct {
    Siblings []DomainCellSibling `xml:"sibling"`
}

type DomainCellSibling Uses

type DomainCellSibling struct {
    ID    uint `xml:"id,attr"`
    Value uint `xml:"value,attr"`
}

type DomainChannel Uses

type DomainChannel struct {
    XMLName  xml.Name               `xml:"channel"`
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
    Target   *DomainChannelTarget   `xml:"target"`
    Log      *DomainChardevLog      `xml:"log"`
    Alias    *DomainAlias           `xml:"alias"`
    Address  *DomainAddress         `xml:"address"`
}

func (*DomainChannel) Marshal Uses

func (d *DomainChannel) Marshal() (string, error)

func (*DomainChannel) MarshalXML Uses

func (a *DomainChannel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChannel) Unmarshal Uses

func (d *DomainChannel) Unmarshal(doc string) error

func (*DomainChannel) UnmarshalXML Uses

func (a *DomainChannel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChannelTarget Uses

type DomainChannelTarget struct {
    VirtIO   *DomainChannelTargetVirtIO   `xml:"-"`
    Xen      *DomainChannelTargetXen      `xml:"-"`
    GuestFWD *DomainChannelTargetGuestFWD `xml:"-"`
}

func (*DomainChannelTarget) MarshalXML Uses

func (a *DomainChannelTarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChannelTarget) UnmarshalXML Uses

func (a *DomainChannelTarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChannelTargetGuestFWD Uses

type DomainChannelTargetGuestFWD struct {
    Address string `xml:"address,attr,omitempty"`
    Port    string `xml:"port,attr,omitempty"`
}

type DomainChannelTargetVirtIO Uses

type DomainChannelTargetVirtIO struct {
    Name  string `xml:"name,attr,omitempty"`
    State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

type DomainChannelTargetXen Uses

type DomainChannelTargetXen struct {
    Name  string `xml:"name,attr,omitempty"`
    State string `xml:"state,attr,omitempty"` // is guest agent connected?
}

type DomainChardevLog Uses

type DomainChardevLog struct {
    File   string `xml:"file,attr"`
    Append string `xml:"append,attr,omitempty"`
}

type DomainChardevProtocol Uses

type DomainChardevProtocol struct {
    Type string `xml:"type,attr"`
}

type DomainChardevSource Uses

type DomainChardevSource struct {
    Null      *DomainChardevSourceNull      `xml:"-"`
    VC        *DomainChardevSourceVC        `xml:"-"`
    Pty       *DomainChardevSourcePty       `xml:"-"`
    Dev       *DomainChardevSourceDev       `xml:"-"`
    File      *DomainChardevSourceFile      `xml:"-"`
    Pipe      *DomainChardevSourcePipe      `xml:"-"`
    StdIO     *DomainChardevSourceStdIO     `xml:"-"`
    UDP       *DomainChardevSourceUDP       `xml:"-"`
    TCP       *DomainChardevSourceTCP       `xml:"-"`
    UNIX      *DomainChardevSourceUNIX      `xml:"-"`
    SpiceVMC  *DomainChardevSourceSpiceVMC  `xml:"-"`
    SpicePort *DomainChardevSourceSpicePort `xml:"-"`
    NMDM      *DomainChardevSourceNMDM      `xml:"-"`
}

func (*DomainChardevSource) MarshalXML Uses

func (a *DomainChardevSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainChardevSource) UnmarshalXML Uses

func (a *DomainChardevSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainChardevSourceDev Uses

type DomainChardevSourceDev struct {
    Path     string                 `xml:"path,attr"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceFile Uses

type DomainChardevSourceFile struct {
    Path     string                 `xml:"path,attr"`
    Append   string                 `xml:"append,attr,omitempty"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceNMDM Uses

type DomainChardevSourceNMDM struct {
    Master string `xml:"master,attr"`
    Slave  string `xml:"slave,attr"`
}

type DomainChardevSourceNull Uses

type DomainChardevSourceNull struct {
}

type DomainChardevSourcePipe Uses

type DomainChardevSourcePipe struct {
    Path     string                 `xml:"path,attr"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourcePty Uses

type DomainChardevSourcePty struct {
    Path     string                 `xml:"path,attr"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainChardevSourceReconnect Uses

type DomainChardevSourceReconnect struct {
    Enabled string `xml:"enabled,attr"`
    Timeout *uint  `xml:"timeout,attr"`
}

type DomainChardevSourceSpicePort Uses

type DomainChardevSourceSpicePort struct {
    Channel string `xml:"channel,attr"`
}

type DomainChardevSourceSpiceVMC Uses

type DomainChardevSourceSpiceVMC struct {
}

type DomainChardevSourceStdIO Uses

type DomainChardevSourceStdIO struct {
}

type DomainChardevSourceTCP Uses

type DomainChardevSourceTCP struct {
    Mode      string                        `xml:"mode,attr,omitempty"`
    Host      string                        `xml:"host,attr,omitempty"`
    Service   string                        `xml:"service,attr,omitempty"`
    TLS       string                        `xml:"tls,attr,omitempty"`
    Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
}

type DomainChardevSourceUDP Uses

type DomainChardevSourceUDP struct {
    BindHost       string `xml:"-"`
    BindService    string `xml:"-"`
    ConnectHost    string `xml:"-"`
    ConnectService string `xml:"-"`
}

type DomainChardevSourceUNIX Uses

type DomainChardevSourceUNIX struct {
    Mode      string                        `xml:"mode,attr,omitempty"`
    Path      string                        `xml:"path,attr"`
    Reconnect *DomainChardevSourceReconnect `xml:"reconnect"`
    SecLabel  []DomainDeviceSecLabel        `xml:"seclabel"`
}

type DomainChardevSourceVC Uses

type DomainChardevSourceVC struct {
}

type DomainChardevTarget Uses

type DomainChardevTarget struct {
    Type  string `xml:"type,attr,omitempty"`
    Name  string `xml:"name,attr,omitempty"`
    State string `xml:"state,attr,omitempty"` // is guest agent connected?
    Port  *uint  `xml:"port,attr"`
}

type DomainClock Uses

type DomainClock struct {
    Offset     string        `xml:"offset,attr,omitempty"`
    Basis      string        `xml:"basis,attr,omitempty"`
    Adjustment string        `xml:"adjustment,attr,omitempty"`
    TimeZone   string        `xml:"timezone,attr,omitempty"`
    Timer      []DomainTimer `xml:"timer"`
}

type DomainConsole Uses

type DomainConsole struct {
    XMLName  xml.Name               `xml:"console"`
    TTY      string                 `xml:"tty,attr,omitempty"`
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
    Target   *DomainConsoleTarget   `xml:"target"`
    Log      *DomainChardevLog      `xml:"log"`
    Alias    *DomainAlias           `xml:"alias"`
    Address  *DomainAddress         `xml:"address"`
}

func (*DomainConsole) Marshal Uses

func (d *DomainConsole) Marshal() (string, error)

func (*DomainConsole) MarshalXML Uses

func (a *DomainConsole) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainConsole) Unmarshal Uses

func (d *DomainConsole) Unmarshal(doc string) error

func (*DomainConsole) UnmarshalXML Uses

func (a *DomainConsole) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainConsoleTarget Uses

type DomainConsoleTarget struct {
    Type string `xml:"type,attr,omitempty"`
    Port *uint  `xml:"port,attr"`
}

type DomainController Uses

type DomainController struct {
    XMLName      xml.Name                      `xml:"controller"`
    Type         string                        `xml:"type,attr"`
    Index        *uint                         `xml:"index,attr"`
    Model        string                        `xml:"model,attr,omitempty"`
    Driver       *DomainControllerDriver       `xml:"driver"`
    PCI          *DomainControllerPCI          `xml:"-"`
    USB          *DomainControllerUSB          `xml:"-"`
    VirtIOSerial *DomainControllerVirtIOSerial `xml:"-"`
    Alias        *DomainAlias                  `xml:"alias"`
    Address      *DomainAddress                `xml:"address"`
}

func (*DomainController) Marshal Uses

func (d *DomainController) Marshal() (string, error)

func (*DomainController) MarshalXML Uses

func (a *DomainController) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainController) Unmarshal Uses

func (d *DomainController) Unmarshal(doc string) error

func (*DomainController) UnmarshalXML Uses

func (a *DomainController) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainControllerDriver Uses

type DomainControllerDriver struct {
    Queues     *uint  `xml:"queues,attr"`
    CmdPerLUN  *uint  `xml:"cmd_per_lun,attr"`
    MaxSectors *uint  `xml:"max_sectors,attr"`
    IOEventFD  string `xml:"ioeventfd,attr,omitempty"`
    IOThread   uint   `xml:"iothread,attr,omitempty"`
    IOMMU      string `xml:"iommu,attr,omitempty"`
    ATS        string `xml:"ats,attr,omitempty"`
}

type DomainControllerPCI Uses

type DomainControllerPCI struct {
    Model  *DomainControllerPCIModel  `xml:"model"`
    Target *DomainControllerPCITarget `xml:"target"`
    Hole64 *DomainControllerPCIHole64 `xml:"pcihole64"`
}

type DomainControllerPCIHole64 Uses

type DomainControllerPCIHole64 struct {
    Size uint64 `xml:",chardata"`
    Unit string `xml:"unit,attr,omitempty"`
}

type DomainControllerPCIModel Uses

type DomainControllerPCIModel struct {
    Name string `xml:"name,attr"`
}

type DomainControllerPCITarget Uses

type DomainControllerPCITarget struct {
    ChassisNr *uint
    Chassis   *uint
    Port      *uint
    BusNr     *uint
    Index     *uint
    NUMANode  *uint
}

func (*DomainControllerPCITarget) MarshalXML Uses

func (a *DomainControllerPCITarget) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainControllerPCITarget) UnmarshalXML Uses

func (a *DomainControllerPCITarget) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainControllerUSB Uses

type DomainControllerUSB struct {
    Port   *uint                      `xml:"ports,attr"`
    Master *DomainControllerUSBMaster `xml:"master"`
}

type DomainControllerUSBMaster Uses

type DomainControllerUSBMaster struct {
    StartPort uint `xml:"startport,attr"`
}

type DomainControllerVirtIOSerial Uses

type DomainControllerVirtIOSerial struct {
    Ports   *uint `xml:"ports,attr"`
    Vectors *uint `xml:"vectors,attr"`
}

type DomainCurrentMemory Uses

type DomainCurrentMemory struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainDeviceBoot Uses

type DomainDeviceBoot struct {
    Order    uint   `xml:"order,attr"`
    LoadParm string `xml:"loadparm,attr,omitempty"`
}

type DomainDeviceList Uses

type DomainDeviceList struct {
    Emulator     string              `xml:"emulator,omitempty"`
    Disks        []DomainDisk        `xml:"disk"`
    Controllers  []DomainController  `xml:"controller"`
    Leases       []DomainLease       `xml:"lease"`
    Filesystems  []DomainFilesystem  `xml:"filesystem"`
    Interfaces   []DomainInterface   `xml:"interface"`
    Smartcards   []DomainSmartcard   `xml:"smartcard"`
    Serials      []DomainSerial      `xml:"serial"`
    Parallels    []DomainParallel    `xml:"parallel"`
    Consoles     []DomainConsole     `xml:"console"`
    Channels     []DomainChannel     `xml:"channel"`
    Inputs       []DomainInput       `xml:"input"`
    TPMs         []DomainTPM         `xml:"tpm"`
    Graphics     []DomainGraphic     `xml:"graphics"`
    Sounds       []DomainSound       `xml:"sound"`
    Videos       []DomainVideo       `xml:"video"`
    Hostdevs     []DomainHostdev     `xml:"hostdev"`
    RedirDevs    []DomainRedirDev    `xml:"redirdev"`
    RedirFilters []DomainRedirFilter `xml:"redirfilter"`
    Hubs         []DomainHub         `xml:"hub"`
    Watchdog     *DomainWatchdog     `xml:"watchdog"`
    MemBalloon   *DomainMemBalloon   `xml:"memballoon"`
    RNGs         []DomainRNG         `xml:"rng"`
    NVRAM        *DomainNVRAM        `xml:"nvram"`
    Panics       []DomainPanic       `xml:"panic"`
    Shmems       []DomainShmem       `xml:"shmem"`
    Memorydevs   []DomainMemorydev   `xml:"memory"`
    IOMMU        *DomainIOMMU        `xml:"iommu"`
}

type DomainDeviceSecLabel Uses

type DomainDeviceSecLabel struct {
    Model     string `xml:"model,attr,omitempty"`
    LabelSkip string `xml:"labelskip,attr,omitempty"`
    Relabel   string `xml:"relabel,attr,omitempty"`
    Label     string `xml:"label,omitempty"`
}

type DomainDisk Uses

type DomainDisk struct {
    XMLName      xml.Name                `xml:"disk"`
    Device       string                  `xml:"device,attr,omitempty"`
    RawIO        string                  `xml:"rawio,attr,omitempty"`
    SGIO         string                  `xml:"sgio,attr,omitempty"`
    Snapshot     string                  `xml:"snapshot,attr,omitempty"`
    Driver       *DomainDiskDriver       `xml:"driver"`
    Auth         *DomainDiskAuth         `xml:"auth"`
    Source       *DomainDiskSource       `xml:"source"`
    BackingStore *DomainDiskBackingStore `xml:"backingStore"`
    Geometry     *DomainDiskGeometry     `xml:"geometry"`
    BlockIO      *DomainDiskBlockIO      `xml:"blockio"`
    Mirror       *DomainDiskMirror       `xml:"mirror"`
    Target       *DomainDiskTarget       `xml:"target"`
    IOTune       *DomainDiskIOTune       `xml:"iotune"`
    ReadOnly     *DomainDiskReadOnly     `xml:"readonly"`
    Shareable    *DomainDiskShareable    `xml:"shareable"`
    Transient    *DomainDiskTransient    `xml:"transient"`
    Serial       string                  `xml:"serial,omitempty"`
    WWN          string                  `xml:"wwn,omitempty"`
    Vendor       string                  `xml:"vendor,omitempty"`
    Product      string                  `xml:"product,omitempty"`
    Encryption   *DomainDiskEncryption   `xml:"encryption"`
    Boot         *DomainDeviceBoot       `xml:"boot"`
    Alias        *DomainAlias            `xml:"alias"`
    Address      *DomainAddress          `xml:"address"`
}

func (*DomainDisk) Marshal Uses

func (d *DomainDisk) Marshal() (string, error)

func (*DomainDisk) MarshalXML Uses

func (a *DomainDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDisk) Unmarshal Uses

func (d *DomainDisk) Unmarshal(doc string) error

func (*DomainDisk) UnmarshalXML Uses

func (a *DomainDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskAuth Uses

type DomainDiskAuth struct {
    Username string            `xml:"username,attr,omitempty"`
    Secret   *DomainDiskSecret `xml:"secret"`
}

type DomainDiskBackingStore Uses

type DomainDiskBackingStore struct {
    Index        uint                    `xml:"index,attr,omitempty"`
    Format       *DomainDiskFormat       `xml:"format"`
    Source       *DomainDiskSource       `xml:"source"`
    BackingStore *DomainDiskBackingStore `xml:"backingStore"`
}

func (*DomainDiskBackingStore) MarshalXML Uses

func (a *DomainDiskBackingStore) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskBackingStore) UnmarshalXML Uses

func (a *DomainDiskBackingStore) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskBlockIO Uses

type DomainDiskBlockIO struct {
    LogicalBlockSize  uint `xml:"logical_block_size,attr,omitempty"`
    PhysicalBlockSize uint `xml:"physical_block_size,attr,omitempty"`
}

type DomainDiskDriver Uses

type DomainDiskDriver struct {
    Name         string `xml:"name,attr,omitempty"`
    Type         string `xml:"type,attr,omitempty"`
    Cache        string `xml:"cache,attr,omitempty"`
    ErrorPolicy  string `xml:"error_policy,attr,omitempty"`
    RErrorPolicy string `xml:"rerror_policy,attr,omitempty"`
    IO           string `xml:"io,attr,omitempty"`
    IOEventFD    string `xml:"ioeventfd,attr,omitempty"`
    EventIDX     string `xml:"event_idx,attr,omitempty"`
    CopyOnRead   string `xml:"copy_on_read,attr,omitempty"`
    Discard      string `xml:"discard,attr,omitempty"`
    IOThread     *uint  `xml:"iothread,attr"`
    DetectZeros  string `xml:"detect_zeroes,attr,omitempty"`
    Queues       *uint  `xml:"queues,attr"`
    IOMMU        string `xml:"iommu,attr,omitempty"`
    ATS          string `xml:"ats,attr,omitempty"`
}

type DomainDiskEncryption Uses

type DomainDiskEncryption struct {
    Format string            `xml:"format,attr,omitempty"`
    Secret *DomainDiskSecret `xml:"secret"`
}

type DomainDiskFormat Uses

type DomainDiskFormat struct {
    Type string `xml:"type,attr"`
}

type DomainDiskGeometry Uses

type DomainDiskGeometry struct {
    Cylinders uint   `xml:"cyls,attr"`
    Headers   uint   `xml:"heads,attr"`
    Sectors   uint   `xml:"secs,attr"`
    Trans     string `xml:"trans,attr,omitempty"`
}

type DomainDiskIOTune Uses

type DomainDiskIOTune struct {
    TotalBytesSec          uint64 `xml:"total_bytes_sec,omitempty"`
    ReadBytesSec           uint64 `xml:"read_bytes_sec,omitempty"`
    WriteBytesSec          uint64 `xml:"write_bytes_sec,omitempty"`
    TotalIopsSec           uint64 `xml:"total_iops_sec,omitempty"`
    ReadIopsSec            uint64 `xml:"read_iops_sec,omitempty"`
    WriteIopsSec           uint64 `xml:"write_iops_sec,omitempty"`
    TotalBytesSecMax       uint64 `xml:"total_bytes_sec_max,omitempty"`
    ReadBytesSecMax        uint64 `xml:"read_bytes_sec_max,omitempty"`
    WriteBytesSecMax       uint64 `xml:"write_bytes_sec_max,omitempty"`
    TotalIopsSecMax        uint64 `xml:"total_iops_sec_max,omitempty"`
    ReadIopsSecMax         uint64 `xml:"read_iops_sec_max,omitempty"`
    WriteIopsSecMax        uint64 `xml:"write_iops_sec_max,omitempty"`
    TotalBytesSecMaxLength uint64 `xml:"total_bytes_sec_max_length,omitempty"`
    ReadBytesSecMaxLength  uint64 `xml:"read_bytes_sec_max_length,omitempty"`
    WriteBytesSecMaxLength uint64 `xml:"write_bytes_sec_max_length,omitempty"`
    TotalIopsSecMaxLength  uint64 `xml:"total_iops_sec_max_length,omitempty"`
    ReadIopsSecMaxLength   uint64 `xml:"read_iops_sec_max_length,omitempty"`
    WriteIopsSecMaxLength  uint64 `xml:"write_iops_sec_max_length,omitempty"`
    SizeIopsSec            uint64 `xml:"size_iops_sec,omitempty"`
    GroupName              string `xml:"group_name,omitempty"`
}

type DomainDiskMirror Uses

type DomainDiskMirror struct {
    Job    string            `xml:"job,attr,omitempty"`
    Ready  string            `xml:"ready,attr,omitempty"`
    Format *DomainDiskFormat `xml:"format"`
    Source *DomainDiskSource `xml:"source"`
}

func (*DomainDiskMirror) MarshalXML Uses

func (a *DomainDiskMirror) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskMirror) UnmarshalXML Uses

func (a *DomainDiskMirror) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskReadOnly Uses

type DomainDiskReadOnly struct {
}

type DomainDiskSecret Uses

type DomainDiskSecret struct {
    Type  string `xml:"type,attr,omitempty"`
    Usage string `xml:"usage,attr,omitempty"`
    UUID  string `xml:"uuid,attr,omitempty"`
}

type DomainDiskShareable Uses

type DomainDiskShareable struct {
}

type DomainDiskSource Uses

type DomainDiskSource struct {
    File          *DomainDiskSourceFile    `xml:"-"`
    Block         *DomainDiskSourceBlock   `xml:"-"`
    Dir           *DomainDiskSourceDir     `xml:"-"`
    Network       *DomainDiskSourceNetwork `xml:"-"`
    Volume        *DomainDiskSourceVolume  `xml:"-"`
    StartupPolicy string                   `xml:"startupPolicy,attr,omitempty"`
    Encryption    *DomainDiskEncryption    `xml:"encryption"`
}

func (*DomainDiskSource) MarshalXML Uses

func (a *DomainDiskSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainDiskSource) UnmarshalXML Uses

func (a *DomainDiskSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainDiskSourceBlock Uses

type DomainDiskSourceBlock struct {
    Dev      string                 `xml:"dev,attr,omitempty"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskSourceDir Uses

type DomainDiskSourceDir struct {
    Dir string `xml:"dir,attr,omitempty"`
}

type DomainDiskSourceFile Uses

type DomainDiskSourceFile struct {
    File     string                 `xml:"file,attr,omitempty"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskSourceHost Uses

type DomainDiskSourceHost struct {
    Transport string `xml:"transport,attr,omitempty"`
    Name      string `xml:"name,attr,omitempty"`
    Port      string `xml:"port,attr,omitempty"`
    Socket    string `xml:"socket,attr,omitempty"`
}

type DomainDiskSourceNetwork Uses

type DomainDiskSourceNetwork struct {
    Protocol string                           `xml:"protocol,attr,omitempty"`
    Name     string                           `xml:"name,attr,omitempty"`
    TLS      string                           `xml:"tls,attr,omitempty"`
    Hosts    []DomainDiskSourceHost           `xml:"host"`
    Snapshot *DomainDiskSourceNetworkSnapshot `xml:"snapshot"`
    Config   *DomainDiskSourceNetworkConfig   `xml:"config"`
    Auth     *DomainDiskAuth                  `xml:"auth"`
}

type DomainDiskSourceNetworkConfig Uses

type DomainDiskSourceNetworkConfig struct {
    File string `xml:"file,attr"`
}

type DomainDiskSourceNetworkSnapshot Uses

type DomainDiskSourceNetworkSnapshot struct {
    Name string `xml:"name,attr"`
}

type DomainDiskSourceVolume Uses

type DomainDiskSourceVolume struct {
    Pool     string                 `xml:"pool,attr,omitempty"`
    Volume   string                 `xml:"volume,attr,omitempty"`
    Mode     string                 `xml:"mode,attr,omitempty"`
    SecLabel []DomainDeviceSecLabel `xml:"seclabel"`
}

type DomainDiskTarget Uses

type DomainDiskTarget struct {
    Dev       string `xml:"dev,attr,omitempty"`
    Bus       string `xml:"bus,attr,omitempty"`
    Tray      string `xml:"tray,attr,omitempty"`
    Removable string `xml:"removable,attr,omitempty"`
}

type DomainDiskTransient Uses

type DomainDiskTransient struct {
}

type DomainFeature Uses

type DomainFeature struct {
}

type DomainFeatureAPIC Uses

type DomainFeatureAPIC struct {
    EOI string `xml:"eoi,attr,omitempty"`
}

type DomainFeatureCapabilities Uses

type DomainFeatureCapabilities struct {
    Policy         string                   `xml:"policy,attr,omitempty"`
    AuditControl   *DomainFeatureCapability `xml:"audit_control"`
    AuditWrite     *DomainFeatureCapability `xml:"audit_write"`
    BlockSuspend   *DomainFeatureCapability `xml:"block_suspend"`
    Chown          *DomainFeatureCapability `xml:"chown"`
    DACOverride    *DomainFeatureCapability `xml:"dac_override"`
    DACReadSearch  *DomainFeatureCapability `xml:"dac_read_Search"`
    FOwner         *DomainFeatureCapability `xml:"fowner"`
    FSetID         *DomainFeatureCapability `xml:"fsetid"`
    IPCLock        *DomainFeatureCapability `xml:"ipc_lock"`
    IPCOwner       *DomainFeatureCapability `xml:"ipc_owner"`
    Kill           *DomainFeatureCapability `xml:"kill"`
    Lease          *DomainFeatureCapability `xml:"lease"`
    LinuxImmutable *DomainFeatureCapability `xml:"linux_immutable"`
    MACAdmin       *DomainFeatureCapability `xml:"mac_admin"`
    MACOverride    *DomainFeatureCapability `xml:"mac_override"`
    MkNod          *DomainFeatureCapability `xml:"mknod"`
    NetAdmin       *DomainFeatureCapability `xml:"net_admin"`
    NetBindService *DomainFeatureCapability `xml:"net_bind_service"`
    NetBroadcast   *DomainFeatureCapability `xml:"net_broadcast"`
    NetRaw         *DomainFeatureCapability `xml:"net_raw"`
    SetGID         *DomainFeatureCapability `xml:"setgid"`
    SetFCap        *DomainFeatureCapability `xml:"setfcap"`
    SetPCap        *DomainFeatureCapability `xml:"setpcap"`
    SetUID         *DomainFeatureCapability `xml:"setuid"`
    SysAdmin       *DomainFeatureCapability `xml:"sys_admin"`
    SysBoot        *DomainFeatureCapability `xml:"sys_boot"`
    SysChRoot      *DomainFeatureCapability `xml:"sys_chroot"`
    SysModule      *DomainFeatureCapability `xml:"sys_module"`
    SysNice        *DomainFeatureCapability `xml:"sys_nice"`
    SysPAcct       *DomainFeatureCapability `xml:"sys_pacct"`
    SysPTrace      *DomainFeatureCapability `xml:"sys_ptrace"`
    SysRawIO       *DomainFeatureCapability `xml:"sys_rawio"`
    SysResource    *DomainFeatureCapability `xml:"sys_resource"`
    SysTime        *DomainFeatureCapability `xml:"sys_time"`
    SysTTYCnofig   *DomainFeatureCapability `xml:"sys_tty_config"`
    SysLog         *DomainFeatureCapability `xml:"syslog"`
    WakeAlarm      *DomainFeatureCapability `xml:"wake_alarm"`
}

type DomainFeatureCapability Uses

type DomainFeatureCapability struct {
    State string `xml:"state,attr,omitempty"`
}

type DomainFeatureGIC Uses

type DomainFeatureGIC struct {
    Version string `xml:"version,attr,omitempty"`
}

type DomainFeatureHPT Uses

type DomainFeatureHPT struct {
    Resizing string `xml:"resizing,attr,omitempty"`
}

type DomainFeatureHyperV Uses

type DomainFeatureHyperV struct {
    DomainFeature
    Relaxed   *DomainFeatureState           `xml:"relaxed"`
    VAPIC     *DomainFeatureState           `xml:"vapic"`
    Spinlocks *DomainFeatureHyperVSpinlocks `xml:"spinlocks"`
    VPIndex   *DomainFeatureState           `xml:"vpindex"`
    Runtime   *DomainFeatureState           `xml:"runtime"`
    Synic     *DomainFeatureState           `xml:"synic"`
    STimer    *DomainFeatureState           `xml:"stimer"`
    Reset     *DomainFeatureState           `xml:"reset"`
    VendorId  *DomainFeatureHyperVVendorId  `xml:"vendor_id"`
}

type DomainFeatureHyperVSpinlocks Uses

type DomainFeatureHyperVSpinlocks struct {
    DomainFeatureState
    Retries uint `xml:"retries,attr,omitempty"`
}

type DomainFeatureHyperVVendorId Uses

type DomainFeatureHyperVVendorId struct {
    DomainFeatureState
    Value string `xml:"value,attr,omitempty"`
}

type DomainFeatureIOAPIC Uses

type DomainFeatureIOAPIC struct {
    Driver string `xml:"driver,attr,omitempty"`
}

type DomainFeatureKVM Uses

type DomainFeatureKVM struct {
    Hidden *DomainFeatureState `xml:"hidden"`
}

type DomainFeatureList Uses

type DomainFeatureList struct {
    PAE          *DomainFeature             `xml:"pae"`
    ACPI         *DomainFeature             `xml:"acpi"`
    APIC         *DomainFeatureAPIC         `xml:"apic"`
    HAP          *DomainFeatureState        `xml:"hap"`
    Viridian     *DomainFeature             `xml:"viridian"`
    PrivNet      *DomainFeature             `xml:"privnet"`
    HyperV       *DomainFeatureHyperV       `xml:"hyperv"`
    KVM          *DomainFeatureKVM          `xml:"kvm"`
    PVSpinlock   *DomainFeatureState        `xml:"pvspinlock"`
    PMU          *DomainFeatureState        `xml:"pmu"`
    VMPort       *DomainFeatureState        `xml:"vmport"`
    GIC          *DomainFeatureGIC          `xml:"gic"`
    SMM          *DomainFeatureState        `xml:"smm"`
    IOAPIC       *DomainFeatureIOAPIC       `xml:"ioapic"`
    HPT          *DomainFeatureHPT          `xml:"hpt"`
    Capabilities *DomainFeatureCapabilities `xml:"capabilities"`
    VMCoreInfo   *DomainFeature             `xml:"vmcoreinfo"`
}

type DomainFeatureState Uses

type DomainFeatureState struct {
    State string `xml:"state,attr,omitempty"`
}

type DomainFilesystem Uses

type DomainFilesystem struct {
    XMLName        xml.Name                        `xml:"filesystem"`
    AccessMode     string                          `xml:"accessmode,attr,omitempty"`
    Driver         *DomainFilesystemDriver         `xml:"driver"`
    Source         *DomainFilesystemSource         `xml:"source"`
    Target         *DomainFilesystemTarget         `xml:"target"`
    ReadOnly       *DomainFilesystemReadOnly       `xml:"readonly"`
    SpaceHardLimit *DomainFilesystemSpaceHardLimit `xml:"space_hard_limit"`
    SpaceSoftLimit *DomainFilesystemSpaceSoftLimit `xml:"space_soft_limit"`
    Alias          *DomainAlias                    `xml:"alias"`
    Address        *DomainAddress                  `xml:"address"`
}

func (*DomainFilesystem) Marshal Uses

func (d *DomainFilesystem) Marshal() (string, error)

func (*DomainFilesystem) MarshalXML Uses

func (a *DomainFilesystem) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainFilesystem) Unmarshal Uses

func (d *DomainFilesystem) Unmarshal(doc string) error

func (*DomainFilesystem) UnmarshalXML Uses

func (a *DomainFilesystem) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainFilesystemDriver Uses

type DomainFilesystemDriver struct {
    Type     string `xml:"type,attr,omitempty"`
    Format   string `xml:"format,attr,omitempty"`
    Name     string `xml:"name,attr,omitempty"`
    WRPolicy string `xml:"wrpolicy,attr,omitempty"`
    IOMMU    string `xml:"iommu,attr,omitempty"`
    ATS      string `xml:"ats,attr,omitempty"`
}

type DomainFilesystemReadOnly Uses

type DomainFilesystemReadOnly struct {
}

type DomainFilesystemSource Uses

type DomainFilesystemSource struct {
    Mount    *DomainFilesystemSourceMount    `xml:"-"`
    Block    *DomainFilesystemSourceBlock    `xml:"-"`
    File     *DomainFilesystemSourceFile     `xml:"-"`
    Template *DomainFilesystemSourceTemplate `xml:"-"`
    RAM      *DomainFilesystemSourceRAM      `xml:"-"`
    Bind     *DomainFilesystemSourceBind     `xml:"-"`
    Volume   *DomainFilesystemSourceVolume   `xml:"-"`
}

func (*DomainFilesystemSource) MarshalXML Uses

func (a *DomainFilesystemSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainFilesystemSource) UnmarshalXML Uses

func (a *DomainFilesystemSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainFilesystemSourceBind Uses

type DomainFilesystemSourceBind struct {
    Dir string `xml:"dir,attr"`
}

type DomainFilesystemSourceBlock Uses

type DomainFilesystemSourceBlock struct {
    Dev string `xml:"dev,attr"`
}

type DomainFilesystemSourceFile Uses

type DomainFilesystemSourceFile struct {
    File string `xml:"file,attr"`
}

type DomainFilesystemSourceMount Uses

type DomainFilesystemSourceMount struct {
    Dir string `xml:"dir,attr"`
}

type DomainFilesystemSourceRAM Uses

type DomainFilesystemSourceRAM struct {
    Usage uint   `xml:"usage,attr"`
    Units string `xml:"units,attr,omitempty"`
}

type DomainFilesystemSourceTemplate Uses

type DomainFilesystemSourceTemplate struct {
    Name string `xml:"name,attr"`
}

type DomainFilesystemSourceVolume Uses

type DomainFilesystemSourceVolume struct {
    Pool   string `xml:"pool,attr"`
    Volume string `xml:"volume,attr"`
}

type DomainFilesystemSpaceHardLimit Uses

type DomainFilesystemSpaceHardLimit struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainFilesystemSpaceSoftLimit Uses

type DomainFilesystemSpaceSoftLimit struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainFilesystemTarget Uses

type DomainFilesystemTarget struct {
    Dir string `xml:"dir,attr"`
}

type DomainGraphic Uses

type DomainGraphic struct {
    XMLName xml.Name              `xml:"graphics"`
    SDL     *DomainGraphicSDL     `xml:"-"`
    VNC     *DomainGraphicVNC     `xml:"-"`
    RDP     *DomainGraphicRDP     `xml:"-"`
    Desktop *DomainGraphicDesktop `xml:"-"`
    Spice   *DomainGraphicSpice   `xml:"-"`
}

func (*DomainGraphic) Marshal Uses

func (d *DomainGraphic) Marshal() (string, error)

func (*DomainGraphic) MarshalXML Uses

func (a *DomainGraphic) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainGraphic) Unmarshal Uses

func (d *DomainGraphic) Unmarshal(doc string) error

func (*DomainGraphic) UnmarshalXML Uses

func (a *DomainGraphic) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainGraphicChannel Uses

type DomainGraphicChannel struct {
    Name string `xml:"name,attr,omitempty"`
    Mode string `xml:"mode,attr,omitempty"`
}

type DomainGraphicDesktop Uses

type DomainGraphicDesktop struct {
    Display    string `xml:"display,attr,omitempty"`
    FullScreen string `xml:"fullscreen,attr,omitempty"`
}

type DomainGraphicFileTransfer Uses

type DomainGraphicFileTransfer struct {
    Enable string `xml:"enable,attr,omitempty"`
}

type DomainGraphicListener Uses

type DomainGraphicListener struct {
    Address *DomainGraphicListenerAddress `xml:"-"`
    Network *DomainGraphicListenerNetwork `xml:"-"`
    Socket  *DomainGraphicListenerSocket  `xml:"-"`
}

func (*DomainGraphicListener) MarshalXML Uses

func (a *DomainGraphicListener) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainGraphicListener) UnmarshalXML Uses

func (a *DomainGraphicListener) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainGraphicListenerAddress Uses

type DomainGraphicListenerAddress struct {
    Address string `xml:"address,attr,omitempty"`
}

type DomainGraphicListenerNetwork Uses

type DomainGraphicListenerNetwork struct {
    Address string `xml:"address,attr,omitempty"`
    Network string `xml:"network,attr,omitempty"`
}

type DomainGraphicListenerSocket Uses

type DomainGraphicListenerSocket struct {
    Socket string `xml:"socket,attr,omitempty"`
}

type DomainGraphicRDP Uses

type DomainGraphicRDP struct {
    Port        int                     `xml:"port,attr,omitempty"`
    AutoPort    string                  `xml:"autoport,attr,omitempty"`
    ReplaceUser string                  `xml:"replaceUser,attr,omitempty"`
    MultiUser   string                  `xml:"multiUser,attr,omitempty"`
    Listen      string                  `xml:"listen,attr,omitempty"`
    Listeners   []DomainGraphicListener `xml:"listen"`
}

type DomainGraphicSDL Uses

type DomainGraphicSDL struct {
    Display    string `xml:"display,attr,omitempty"`
    XAuth      string `xml:"xauth,attr,omitempty"`
    FullScreen string `xml:"fullscreen,attr,omitempty"`
}

type DomainGraphicSpice Uses

type DomainGraphicSpice struct {
    Port          int                             `xml:"port,attr,omitempty"`
    TLSPort       int                             `xml:"tlsPort,attr,omitempty"`
    AutoPort      string                          `xml:"autoport,attr,omitempty"`
    Listen        string                          `xml:"listen,attr,omitempty"`
    Keymap        string                          `xml:"keymap,attr,omitempty"`
    DefaultMode   string                          `xml:"defaultMode,attr,omitempty"`
    Passwd        string                          `xml:"passwd,attr,omitempty"`
    PasswdValidTo string                          `xml:"passwdValidTo,attr,omitempty"`
    Connected     string                          `xml:"connected,attr,omitempty"`
    Listeners     []DomainGraphicListener         `xml:"listen"`
    Channel       []DomainGraphicSpiceChannel     `xml:"channel"`
    Image         *DomainGraphicSpiceImage        `xml:"image"`
    JPEG          *DomainGraphicSpiceJPEG         `xml:"jpeg"`
    ZLib          *DomainGraphicSpiceZLib         `xml:"zlib"`
    Playback      *DomainGraphicSpicePlayback     `xml:"playback"`
    Streaming     *DomainGraphicSpiceStreaming    `xml:"streaming"`
    Mouse         *DomainGraphicSpiceMouse        `xml:"mouse"`
    ClipBoard     *DomainGraphicSpiceClipBoard    `xml:"clipboard"`
    FileTransfer  *DomainGraphicSpiceFileTransfer `xml:"filetransfer"`
    GL            *DomainGraphicSpiceGL           `xml:"gl"`
}

type DomainGraphicSpiceChannel Uses

type DomainGraphicSpiceChannel struct {
    Name string `xml:"name,attr"`
    Mode string `xml:"mode,attr"`
}

type DomainGraphicSpiceClipBoard Uses

type DomainGraphicSpiceClipBoard struct {
    CopyPaste string `xml:"copypaste,attr"`
}

type DomainGraphicSpiceFileTransfer Uses

type DomainGraphicSpiceFileTransfer struct {
    Enable string `xml:"enable,attr"`
}

type DomainGraphicSpiceGL Uses

type DomainGraphicSpiceGL struct {
    Enable     string `xml:"enable,attr,omitempty"`
    RenderNode string `xml:"rendernode,attr,omitempty"`
}

type DomainGraphicSpiceImage Uses

type DomainGraphicSpiceImage struct {
    Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceJPEG Uses

type DomainGraphicSpiceJPEG struct {
    Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceMouse Uses

type DomainGraphicSpiceMouse struct {
    Mode string `xml:"mode,attr"`
}

type DomainGraphicSpicePlayback Uses

type DomainGraphicSpicePlayback struct {
    Compression string `xml:"compression,attr"`
}

type DomainGraphicSpiceStreaming Uses

type DomainGraphicSpiceStreaming struct {
    Mode string `xml:"mode,attr"`
}

type DomainGraphicSpiceZLib Uses

type DomainGraphicSpiceZLib struct {
    Compression string `xml:"compression,attr"`
}

type DomainGraphicVNC Uses

type DomainGraphicVNC struct {
    Socket        string                  `xml:"socket,attr,omitempty"`
    Port          int                     `xml:"port,attr,omitempty"`
    AutoPort      string                  `xml:"autoport,attr,omitempty"`
    WebSocket     int                     `xml:"websocket,attr,omitempty"`
    Keymap        string                  `xml:"keymap,attr,omitempty"`
    SharePolicy   string                  `xml:"sharePolicy,attr,omitempty"`
    Passwd        string                  `xml:"passwd,attr,omitempty"`
    PasswdValidTo string                  `xml:"passwdValidTo,attr,omitempty"`
    Connected     string                  `xml:"connected,attr,omitempty"`
    Listen        string                  `xml:"listen,attr,omitempty"`
    Listeners     []DomainGraphicListener `xml:"listen"`
}

type DomainHostdev Uses

type DomainHostdev struct {
    Managed        string                       `xml:"managed,attr,omitempty"`
    SubsysUSB      *DomainHostdevSubsysUSB      `xml:"-"`
    SubsysSCSI     *DomainHostdevSubsysSCSI     `xml:"-"`
    SubsysSCSIHost *DomainHostdevSubsysSCSIHost `xml:"-"`
    SubsysPCI      *DomainHostdevSubsysPCI      `xml:"-"`
    SubsysMDev     *DomainHostdevSubsysMDev     `xml:"-"`
    CapsStorage    *DomainHostdevCapsStorage    `xml:"-"`
    CapsMisc       *DomainHostdevCapsMisc       `xml:"-"`
    CapsNet        *DomainHostdevCapsNet        `xml:"-"`
    Boot           *DomainDeviceBoot            `xml:"boot"`
    ROM            *DomainROM                   `xml:"rom"`
    Alias          *DomainAlias                 `xml:"alias"`
    Address        *DomainAddress               `xml:"address"`
}

func (*DomainHostdev) Marshal Uses

func (d *DomainHostdev) Marshal() (string, error)

func (*DomainHostdev) MarshalXML Uses

func (a *DomainHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainHostdev) Unmarshal Uses

func (d *DomainHostdev) Unmarshal(doc string) error

func (*DomainHostdev) UnmarshalXML Uses

func (a *DomainHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainHostdevCapsMisc Uses

type DomainHostdevCapsMisc struct {
    Source *DomainHostdevCapsMiscSource `xml:"source"`
}

type DomainHostdevCapsMiscSource Uses

type DomainHostdevCapsMiscSource struct {
    Char string `xml:"char"`
}

type DomainHostdevCapsNet Uses

type DomainHostdevCapsNet struct {
    Source *DomainHostdevCapsNetSource `xml:"source"`
    IP     []DomainIP                  `xml:"ip"`
    Route  []DomainRoute               `xml:"route"`
}

type DomainHostdevCapsNetSource Uses

type DomainHostdevCapsNetSource struct {
    Interface string `xml:"interface"`
}

type DomainHostdevCapsStorage Uses

type DomainHostdevCapsStorage struct {
    Source *DomainHostdevCapsStorageSource `xml:"source"`
}

type DomainHostdevCapsStorageSource Uses

type DomainHostdevCapsStorageSource struct {
    Block string `xml:"block"`
}

type DomainHostdevSubsysMDev Uses

type DomainHostdevSubsysMDev struct {
    Model  string                         `xml:"model,attr,omitempty"`
    Source *DomainHostdevSubsysMDevSource `xml:"source"`
}

type DomainHostdevSubsysMDevSource Uses

type DomainHostdevSubsysMDevSource struct {
    Address *DomainAddressMDev `xml:"address"`
}

type DomainHostdevSubsysPCI Uses

type DomainHostdevSubsysPCI struct {
    Driver *DomainHostdevSubsysPCIDriver `xml:"driver"`
    Source *DomainHostdevSubsysPCISource `xml:"source"`
}

type DomainHostdevSubsysPCIDriver Uses

type DomainHostdevSubsysPCIDriver struct {
    Name string `xml:"name,attr,omitempty"`
}

type DomainHostdevSubsysPCISource Uses

type DomainHostdevSubsysPCISource struct {
    Address *DomainAddressPCI `xml:"address"`
}

type DomainHostdevSubsysSCSI Uses

type DomainHostdevSubsysSCSI struct {
    SGIO      string                         `xml:"sgio,attr,omitempty"`
    RawIO     string                         `xml:"rawio,attr,omitempty"`
    Source    *DomainHostdevSubsysSCSISource `xml:"source"`
    ReadOnly  *DomainDiskReadOnly            `xml:"readonly"`
    Shareable *DomainDiskShareable           `xml:"shareable"`
}

type DomainHostdevSubsysSCSIAdapter Uses

type DomainHostdevSubsysSCSIAdapter struct {
    Name string `xml:"name,attr"`
}

type DomainHostdevSubsysSCSIHost Uses

type DomainHostdevSubsysSCSIHost struct {
    Source *DomainHostdevSubsysSCSIHostSource `xml:"source"`
}

type DomainHostdevSubsysSCSIHostSource Uses

type DomainHostdevSubsysSCSIHostSource struct {
    Protocol string `xml:"protocol,attr,omitempty"`
    WWPN     string `xml:"wwpn,attr,omitempty"`
}

type DomainHostdevSubsysSCSISource Uses

type DomainHostdevSubsysSCSISource struct {
    Host  *DomainHostdevSubsysSCSISourceHost  `xml:"-"`
    ISCSI *DomainHostdevSubsysSCSISourceISCSI `xml:"-"`
}

func (*DomainHostdevSubsysSCSISource) MarshalXML Uses

func (a *DomainHostdevSubsysSCSISource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainHostdevSubsysSCSISource) UnmarshalXML Uses

func (a *DomainHostdevSubsysSCSISource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainHostdevSubsysSCSISourceHost Uses

type DomainHostdevSubsysSCSISourceHost struct {
    Adapter *DomainHostdevSubsysSCSIAdapter `xml:"adapter"`
    Address *DomainAddressDrive             `xml:"address"`
}

type DomainHostdevSubsysSCSISourceISCSI Uses

type DomainHostdevSubsysSCSISourceISCSI struct {
    Name string                 `xml:"name,attr"`
    Host []DomainDiskSourceHost `xml:"host"`
    Auth *DomainDiskAuth        `xml:"auth"`
}

type DomainHostdevSubsysUSB Uses

type DomainHostdevSubsysUSB struct {
    Source *DomainHostdevSubsysUSBSource `xml:"source"`
}

type DomainHostdevSubsysUSBSource Uses

type DomainHostdevSubsysUSBSource struct {
    Address *DomainAddressUSB `xml:"address"`
}

type DomainHub Uses

type DomainHub struct {
    Type    string         `xml:"type,attr"`
    Alias   *DomainAlias   `xml:"alias"`
    Address *DomainAddress `xml:"address"`
}

type DomainIDMap Uses

type DomainIDMap struct {
    UIDs []DomainIDMapRange `xml:"uid"`
    GIDs []DomainIDMapRange `xml:"gid"`
}

type DomainIDMapRange Uses

type DomainIDMapRange struct {
    Start  uint `xml:"start,attr"`
    Target uint `xml:"target,attr"`
    Count  uint `xml:"count,attr"`
}

type DomainIOMMU Uses

type DomainIOMMU struct {
    Model  string             `xml:"model,attr"`
    Driver *DomainIOMMUDriver `xml:"driver"`
}

type DomainIOMMUDriver Uses

type DomainIOMMUDriver struct {
    IntRemap    string `xml:"intremap,attr,omitempty"`
    CachingMode string `xml:"caching_mode,attr,omitempty"`
    EIM         string `xml:"eim,attr,omitempty"`
    IOTLB       string `xml:"iotlb,attr,omitempty"`
}

type DomainIOThread Uses

type DomainIOThread struct {
    ID uint `xml:"id,attr"`
}

type DomainIOThreadIDs Uses

type DomainIOThreadIDs struct {
    IOThreads []DomainIOThread `xml:"iothread"`
}

type DomainIP Uses

type DomainIP struct {
    Address string `xml:"address,attr,omitempty"`
    Family  string `xml:"family,attr,omitempty"`
    Prefix  *uint  `xml:"prefix,attr"`
}

type DomainInput Uses

type DomainInput struct {
    XMLName xml.Name           `xml:"input"`
    Type    string             `xml:"type,attr"`
    Bus     string             `xml:"bus,attr,omitempty"`
    Driver  *DomainInputDriver `xml:"driver"`
    Source  *DomainInputSource `xml:"source"`
    Alias   *DomainAlias       `xml:"alias"`
    Address *DomainAddress     `xml:"address"`
}

func (*DomainInput) Marshal Uses

func (d *DomainInput) Marshal() (string, error)

func (*DomainInput) Unmarshal Uses

func (d *DomainInput) Unmarshal(doc string) error

type DomainInputDriver Uses

type DomainInputDriver struct {
    IOMMU string `xml:"iommu,attr,omitempty"`
    ATS   string `xml:"ats,attr,omitempty"`
}

type DomainInputSource Uses

type DomainInputSource struct {
    EVDev string `xml:"evdev,attr"`
}

type DomainInterface Uses

type DomainInterface struct {
    XMLName             xml.Name                    `xml:"interface"`
    Managed             string                      `xml:"managed,attr,omitempty"`
    TrustGuestRXFilters string                      `xml:"trustGuestRxFilters,attr,omitempty"`
    MAC                 *DomainInterfaceMAC         `xml:"mac"`
    Source              *DomainInterfaceSource      `xml:"source"`
    Boot                *DomainDeviceBoot           `xml:"boot"`
    VLan                *DomainInterfaceVLan        `xml:"vlan"`
    VirtualPort         *DomainInterfaceVirtualPort `xml:"virtualport"`
    IP                  []DomainInterfaceIP         `xml:"ip"`
    Route               []DomainInterfaceRoute      `xml:"route"`
    Script              *DomainInterfaceScript      `xml:"script"`
    Target              *DomainInterfaceTarget      `xml:"target"`
    Guest               *DomainInterfaceGuest       `xml:"guest"`
    Model               *DomainInterfaceModel       `xml:"model"`
    Driver              *DomainInterfaceDriver      `xml:"driver"`
    Backend             *DomainInterfaceBackend     `xml:"backend"`
    FilterRef           *DomainInterfaceFilterRef   `xml:"filterref"`
    Tune                *DomainInterfaceTune        `xml:"tune"`
    Link                *DomainInterfaceLink        `xml:"link"`
    MTU                 *DomainInterfaceMTU         `xml:"mtu"`
    Bandwidth           *DomainInterfaceBandwidth   `xml:"bandwidth"`
    Coalesce            *DomainInterfaceCoalesce    `xml:"coalesce"`
    ROM                 *DomainROM                  `xml:"rom"`
    Alias               *DomainAlias                `xml:"alias"`
    Address             *DomainAddress              `xml:"address"`
}

func (*DomainInterface) Marshal Uses

func (d *DomainInterface) Marshal() (string, error)

func (*DomainInterface) MarshalXML Uses

func (a *DomainInterface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterface) Unmarshal Uses

func (d *DomainInterface) Unmarshal(doc string) error

func (*DomainInterface) UnmarshalXML Uses

func (a *DomainInterface) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceBackend Uses

type DomainInterfaceBackend struct {
    Tap   string `xml:"tap,attr,omitempty"`
    VHost string `xml:"vhost,attr,omitempty"`
}

type DomainInterfaceBandwidth Uses

type DomainInterfaceBandwidth struct {
    Inbound  *DomainInterfaceBandwidthParams `xml:"inbound"`
    Outbound *DomainInterfaceBandwidthParams `xml:"outbound"`
}

type DomainInterfaceBandwidthParams Uses

type DomainInterfaceBandwidthParams struct {
    Average *int `xml:"average,attr"`
    Peak    *int `xml:"peak,attr"`
    Burst   *int `xml:"burst,attr"`
    Floor   *int `xml:"floor,attr"`
}

type DomainInterfaceCoalesce Uses

type DomainInterfaceCoalesce struct {
    RX *DomainInterfaceCoalesceRX `xml:"rx"`
}

type DomainInterfaceCoalesceRX Uses

type DomainInterfaceCoalesceRX struct {
    Frames *DomainInterfaceCoalesceRXFrames `xml:"frames"`
}

type DomainInterfaceCoalesceRXFrames Uses

type DomainInterfaceCoalesceRXFrames struct {
    Max *uint `xml:"max,attr"`
}

type DomainInterfaceDriver Uses

type DomainInterfaceDriver struct {
    Name        string                      `xml:"name,attr,omitempty"`
    TXMode      string                      `xml:"txmode,attr,omitempty"`
    IOEventFD   string                      `xml:"ioeventfd,attr,omitempty"`
    EventIDX    string                      `xml:"event_idx,attr,omitempty"`
    Queues      uint                        `xml:"queues,attr,omitempty"`
    RXQueueSize uint                        `xml:"rx_queue_size,attr,omitempty"`
    TXQueueSize uint                        `xml:"tx_queue_size,attr,omitempty"`
    IOMMU       string                      `xml:"iommu,attr,omitempty"`
    ATS         string                      `xml:"ats,attr,omitempty"`
    Host        *DomainInterfaceDriverHost  `xml:"host"`
    Guest       *DomainInterfaceDriverGuest `xml:"guest"`
}

type DomainInterfaceDriverGuest Uses

type DomainInterfaceDriverGuest struct {
    CSum string `xml:"csum,attr,omitempty"`
    TSO4 string `xml:"tso4,attr,omitempty"`
    TSO6 string `xml:"tso6,attr,omitempty"`
    ECN  string `xml:"ecn,attr,omitempty"`
    UFO  string `xml:"ufo,attr,omitempty"`
}

type DomainInterfaceDriverHost Uses

type DomainInterfaceDriverHost struct {
    CSum     string `xml:"csum,attr,omitempty"`
    GSO      string `xml:"gso,attr,omitempty"`
    TSO4     string `xml:"tso4,attr,omitempty"`
    TSO6     string `xml:"tso6,attr,omitempty"`
    ECN      string `xml:"ecn,attr,omitempty"`
    UFO      string `xml:"ufo,attr,omitempty"`
    MrgRXBuf string `xml:"mrg_rxbuf,attr,omitempty"`
}

type DomainInterfaceFilterParam Uses

type DomainInterfaceFilterParam struct {
    Name  string `xml:"name,attr"`
    Value string `xml:"value,attr"`
}

type DomainInterfaceFilterRef Uses

type DomainInterfaceFilterRef struct {
    Filter      string                       `xml:"filter,attr"`
    Pararmeters []DomainInterfaceFilterParam `xml:"parameter"`
}

type DomainInterfaceGuest Uses

type DomainInterfaceGuest struct {
    Dev    string `xml:"dev,attr,omitempty"`
    Actual string `xml:"actual,attr,omitempty"`
}

type DomainInterfaceIP Uses

type DomainInterfaceIP struct {
    Address string `xml:"address,attr"`
    Family  string `xml:"family,attr,omitempty"`
    Prefix  uint   `xml:"prefix,attr,omitempty"`
    Peer    string `xml:"peer,attr,omitempty"`
}
type DomainInterfaceLink struct {
    State string `xml:"state,attr"`
}

type DomainInterfaceMAC Uses

type DomainInterfaceMAC struct {
    Address string `xml:"address,attr"`
}

type DomainInterfaceMTU Uses

type DomainInterfaceMTU struct {
    Size uint `xml:"size,attr"`
}

type DomainInterfaceModel Uses

type DomainInterfaceModel struct {
    Type string `xml:"type,attr"`
}

type DomainInterfaceRoute Uses

type DomainInterfaceRoute struct {
    Family  string `xml:"family,attr,omitempty"`
    Address string `xml:"address,attr"`
    Netmask string `xml:"netmask,attr,omitempty"`
    Prefix  uint   `xml:"prefix,attr,omitempty"`
    Gateway string `xml:"gateway,attr"`
    Metric  uint   `xml:"metric,attr,omitempty"`
}

type DomainInterfaceScript Uses

type DomainInterfaceScript struct {
    Path string `xml:"path,attr"`
}

type DomainInterfaceSource Uses

type DomainInterfaceSource struct {
    User      *DomainInterfaceSourceUser      `xml:"-"`
    Ethernet  *DomainInterfaceSourceEthernet  `xml:"-"`
    VHostUser *DomainInterfaceSourceVHostUser `xml:"-"`
    Server    *DomainInterfaceSourceServer    `xml:"-"`
    Client    *DomainInterfaceSourceClient    `xml:"-"`
    MCast     *DomainInterfaceSourceMCast     `xml:"-"`
    Network   *DomainInterfaceSourceNetwork   `xml:"-"`
    Bridge    *DomainInterfaceSourceBridge    `xml:"-"`
    Internal  *DomainInterfaceSourceInternal  `xml:"-"`
    Direct    *DomainInterfaceSourceDirect    `xml:"-"`
    Hostdev   *DomainInterfaceSourceHostdev   `xml:"-"`
    UDP       *DomainInterfaceSourceUDP       `xml:"-"`
}

func (*DomainInterfaceSource) MarshalXML Uses

func (a *DomainInterfaceSource) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceSource) UnmarshalXML Uses

func (a *DomainInterfaceSource) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceSourceBridge Uses

type DomainInterfaceSourceBridge struct {
    Bridge string `xml:"bridge,attr"`
}

type DomainInterfaceSourceClient Uses

type DomainInterfaceSourceClient struct {
    Address string                      `xml:"address,attr,omitempty"`
    Port    uint                        `xml:"port,attr,omitempty"`
    Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceDirect Uses

type DomainInterfaceSourceDirect struct {
    Dev  string `xml:"dev,attr,omitempty"`
    Mode string `xml:"mode,attr,omitempty"`
}

type DomainInterfaceSourceEthernet Uses

type DomainInterfaceSourceEthernet struct {
    IP    []DomainInterfaceIP    `xml:"ip"`
    Route []DomainInterfaceRoute `xml:"route"`
}

type DomainInterfaceSourceHostdev Uses

type DomainInterfaceSourceHostdev struct {
    PCI *DomainHostdevSubsysPCISource `xml:"-"`
    USB *DomainHostdevSubsysUSBSource `xml:"-"`
}

func (*DomainInterfaceSourceHostdev) MarshalXML Uses

func (a *DomainInterfaceSourceHostdev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceSourceHostdev) UnmarshalXML Uses

func (a *DomainInterfaceSourceHostdev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceSourceInternal Uses

type DomainInterfaceSourceInternal struct {
    Name string `xml:"name,attr,omitempty"`
}

type DomainInterfaceSourceLocal Uses

type DomainInterfaceSourceLocal struct {
    Address string `xml:"address,attr,omitempty"`
    Port    uint   `xml:"port,attr,omitempty"`
}

type DomainInterfaceSourceMCast Uses

type DomainInterfaceSourceMCast struct {
    Address string                      `xml:"address,attr,omitempty"`
    Port    uint                        `xml:"port,attr,omitempty"`
    Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceNetwork Uses

type DomainInterfaceSourceNetwork struct {
    Network   string `xml:"network,attr,omitempty"`
    PortGroup string `xml:"portgroup,attr,omitempty"`
}

type DomainInterfaceSourceServer Uses

type DomainInterfaceSourceServer struct {
    Address string                      `xml:"address,attr,omitempty"`
    Port    uint                        `xml:"port,attr,omitempty"`
    Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceUDP Uses

type DomainInterfaceSourceUDP struct {
    Address string                      `xml:"address,attr,omitempty"`
    Port    uint                        `xml:"port,attr,omitempty"`
    Local   *DomainInterfaceSourceLocal `xml:"local"`
}

type DomainInterfaceSourceUser Uses

type DomainInterfaceSourceUser struct {
}

type DomainInterfaceSourceVHostUser Uses

type DomainInterfaceSourceVHostUser struct {
    Type string `xml:"type,attr"`
    Path string `xml:"path,attr,omitempty"`
    Mode string `xml:"mode,attr,omitempty"`
}

type DomainInterfaceTarget Uses

type DomainInterfaceTarget struct {
    Dev string `xml:"dev,attr"`
}

type DomainInterfaceTune Uses

type DomainInterfaceTune struct {
    SndBuf uint `xml:"sndbuf"`
}

type DomainInterfaceVLan Uses

type DomainInterfaceVLan struct {
    Trunk string                   `xml:"trunk,attr,omitempty"`
    Tags  []DomainInterfaceVLanTag `xml:"tag"`
}

type DomainInterfaceVLanTag Uses

type DomainInterfaceVLanTag struct {
    ID         uint   `xml:"id,attr"`
    NativeMode string `xml:"nativeMode,attr,omitempty"`
}

type DomainInterfaceVirtualPort Uses

type DomainInterfaceVirtualPort struct {
    Params *DomainInterfaceVirtualPortParams `xml:"parameters"`
}

func (*DomainInterfaceVirtualPort) MarshalXML Uses

func (a *DomainInterfaceVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceVirtualPort) UnmarshalXML Uses

func (a *DomainInterfaceVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceVirtualPortParams Uses

type DomainInterfaceVirtualPortParams struct {
    Any          *DomainInterfaceVirtualPortParamsAny          `xml:"-"`
    VEPA8021QBG  *DomainInterfaceVirtualPortParamsVEPA8021QBG  `xml:"-"`
    VNTag8011QBH *DomainInterfaceVirtualPortParamsVNTag8021QBH `xml:"-"`
    OpenVSwitch  *DomainInterfaceVirtualPortParamsOpenVSwitch  `xml:"-"`
    MidoNet      *DomainInterfaceVirtualPortParamsMidoNet      `xml:"-"`
}

func (*DomainInterfaceVirtualPortParams) MarshalXML Uses

func (a *DomainInterfaceVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainInterfaceVirtualPortParams) UnmarshalXML Uses

func (a *DomainInterfaceVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainInterfaceVirtualPortParamsAny Uses

type DomainInterfaceVirtualPortParamsAny struct {
    ManagerID     *uint  `xml:"managerid,attr"`
    TypeID        *uint  `xml:"typeid,attr"`
    TypeIDVersion *uint  `xml:"typeidversion,attr"`
    InstanceID    string `xml:"instanceid,attr,omitempty"`
    ProfileID     string `xml:"profileid,attr,omitempty"`
    InterfaceID   string `xml:"interfaceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsMidoNet Uses

type DomainInterfaceVirtualPortParamsMidoNet struct {
    InterfaceID string `xml:"interfaceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsOpenVSwitch Uses

type DomainInterfaceVirtualPortParamsOpenVSwitch struct {
    InterfaceID string `xml:"interfaceid,attr,omitempty"`
    ProfileID   string `xml:"profileid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsVEPA8021QBG Uses

type DomainInterfaceVirtualPortParamsVEPA8021QBG struct {
    ManagerID     *uint  `xml:"managerid,attr"`
    TypeID        *uint  `xml:"typeid,attr"`
    TypeIDVersion *uint  `xml:"typeidversion,attr"`
    InstanceID    string `xml:"instanceid,attr,omitempty"`
}

type DomainInterfaceVirtualPortParamsVNTag8021QBH Uses

type DomainInterfaceVirtualPortParamsVNTag8021QBH struct {
    ProfileID string `xml:"profileid,attr,omitempty"`
}

type DomainKeyWrap Uses

type DomainKeyWrap struct {
    Ciphers []DomainKeyWrapCipher `xml:"cipher"`
}

type DomainKeyWrapCipher Uses

type DomainKeyWrapCipher struct {
    Name  string `xml:"name,attr"`
    State string `xml:"state,attr"`
}

type DomainLXCNamespace Uses

type DomainLXCNamespace struct {
    XMLName  xml.Name               `xml:"http://libvirt.org/schemas/domain/lxc/1.0 namespace"`
    ShareNet *DomainLXCNamespaceMap `xml:"sharenet"`
    ShareIPC *DomainLXCNamespaceMap `xml:"shareipc"`
    ShareUTS *DomainLXCNamespaceMap `xml:"shareuts"`
}

type DomainLXCNamespaceMap Uses

type DomainLXCNamespaceMap struct {
    Type  string `xml:"type,attr"`
    Value string `xml:"value,attr"`
}

type DomainLease Uses

type DomainLease struct {
    Lockspace string             `xml:"lockspace"`
    Key       string             `xml:"key"`
    Target    *DomainLeaseTarget `xml:"target"`
}

type DomainLeaseTarget Uses

type DomainLeaseTarget struct {
    Path   string `xml:"path,attr"`
    Offset uint64 `xml:"offset,attr,omitempty"`
}

type DomainLoader Uses

type DomainLoader struct {
    Path     string `xml:",chardata"`
    Readonly string `xml:"readonly,attr,omitempty"`
    Secure   string `xml:"secure,attr,omitempty"`
    Type     string `xml:"type,attr,omitempty"`
}

type DomainMaxMemory Uses

type DomainMaxMemory struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
    Slots uint   `xml:"slots,attr,omitempty"`
}

type DomainMemBalloon Uses

type DomainMemBalloon struct {
    XMLName     xml.Name                `xml:"memballoon"`
    Model       string                  `xml:"model,attr"`
    AutoDeflate string                  `xml:"autodeflate,attr,omitempty"`
    Driver      *DomainMemBalloonDriver `xml:"driver"`
    Stats       *DomainMemBalloonStats  `xml:"stats"`
    Alias       *DomainAlias            `xml:"alias"`
    Address     *DomainAddress          `xml:"address"`
}

func (*DomainMemBalloon) Marshal Uses

func (d *DomainMemBalloon) Marshal() (string, error)

func (*DomainMemBalloon) Unmarshal Uses

func (d *DomainMemBalloon) Unmarshal(doc string) error

type DomainMemBalloonDriver Uses

type DomainMemBalloonDriver struct {
    IOMMU string `xml:"iommu,attr,omitempty"`
    ATS   string `xml:"ats,attr,omitempty"`
}

type DomainMemBalloonStats Uses

type DomainMemBalloonStats struct {
    Period uint `xml:"period,attr"`
}

type DomainMemory Uses

type DomainMemory struct {
    Value    uint   `xml:",chardata"`
    Unit     string `xml:"unit,attr,omitempty"`
    DumpCore string `xml:"dumpCore,attr,omitempty"`
}

type DomainMemoryAccess Uses

type DomainMemoryAccess struct {
    Mode string `xml:"mode,attr,omitempty"`
}

type DomainMemoryAllocation Uses

type DomainMemoryAllocation struct {
    Mode string `xml:"mode,attr,omitempty"`
}

type DomainMemoryBacking Uses

type DomainMemoryBacking struct {
    MemoryHugePages    *DomainMemoryHugepages    `xml:"hugepages"`
    MemoryNosharepages *DomainMemoryNosharepages `xml:"nosharepages"`
    MemoryLocked       *DomainMemoryLocked       `xml:"locked"`
    MemorySource       *DomainMemorySource       `xml:"source"`
    MemoryAccess       *DomainMemoryAccess       `xml:"access"`
    MemoryAllocation   *DomainMemoryAllocation   `xml:"allocation"`
}

type DomainMemoryHugepage Uses

type DomainMemoryHugepage struct {
    Size    uint   `xml:"size,attr"`
    Unit    string `xml:"unit,attr,omitempty"`
    Nodeset string `xml:"nodeset,attr,omitempty"`
}

type DomainMemoryHugepages Uses

type DomainMemoryHugepages struct {
    Hugepages []DomainMemoryHugepage `xml:"page"`
}

type DomainMemoryLocked Uses

type DomainMemoryLocked struct {
}

type DomainMemoryNosharepages Uses

type DomainMemoryNosharepages struct {
}

type DomainMemorySource Uses

type DomainMemorySource struct {
    Type string `xml:"type,attr,omitempty"`
}

type DomainMemoryTune Uses

type DomainMemoryTune struct {
    HardLimit     *DomainMemoryTuneLimit `xml:"hard_limit"`
    SoftLimit     *DomainMemoryTuneLimit `xml:"soft_limit"`
    MinGuarantee  *DomainMemoryTuneLimit `xml:"min_guarantee"`
    SwapHardLimit *DomainMemoryTuneLimit `xml:"swap_hard_limit"`
}

type DomainMemoryTuneLimit Uses

type DomainMemoryTuneLimit struct {
    Value uint64 `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainMemorydev Uses

type DomainMemorydev struct {
    XMLName xml.Name               `xml:"memory"`
    Model   string                 `xml:"model,attr"`
    Access  string                 `xml:"access,attr,omitempty"`
    Source  *DomainMemorydevSource `xml:"source"`
    Target  *DomainMemorydevTarget `xml:"target"`
    Alias   *DomainAlias           `xml:"alias"`
    Address *DomainAddress         `xml:"address"`
}

func (*DomainMemorydev) Marshal Uses

func (d *DomainMemorydev) Marshal() (string, error)

func (*DomainMemorydev) Unmarshal Uses

func (d *DomainMemorydev) Unmarshal(doc string) error

type DomainMemorydevSource Uses

type DomainMemorydevSource struct {
    NodeMask string                         `xml:"nodemask,omitempty"`
    PageSize *DomainMemorydevSourcePagesize `xml:"pagesize"`
    Path     string                         `xml:"path,omitempty"`
}

type DomainMemorydevSourcePagesize Uses

type DomainMemorydevSourcePagesize struct {
    Value uint64 `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainMemorydevTarget Uses

type DomainMemorydevTarget struct {
    Size  *DomainMemorydevTargetSize  `xml:"size"`
    Node  *DomainMemorydevTargetNode  `xml:"node"`
    Label *DomainMemorydevTargetLabel `xml:"label"`
}

type DomainMemorydevTargetLabel Uses

type DomainMemorydevTargetLabel struct {
    Size *DomainMemorydevTargetSize `xml:"size"`
}

type DomainMemorydevTargetNode Uses

type DomainMemorydevTargetNode struct {
    Value uint `xml:",chardata"`
}

type DomainMemorydevTargetSize Uses

type DomainMemorydevTargetSize struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainMetadata Uses

type DomainMetadata struct {
    XML string `xml:",innerxml"`
}

type DomainNUMATune Uses

type DomainNUMATune struct {
    Memory   *DomainNUMATuneMemory   `xml:"memory"`
    MemNodes []DomainNUMATuneMemNode `xml:"memnode"`
}

type DomainNUMATuneMemNode Uses

type DomainNUMATuneMemNode struct {
    CellID  uint   `xml:"cellid,attr"`
    Mode    string `xml:"mode,attr"`
    Nodeset string `xml:"nodeset,attr"`
}

type DomainNUMATuneMemory Uses

type DomainNUMATuneMemory struct {
    Mode      string `xml:"mode,attr,omitempty"`
    Nodeset   string `xml:"nodeset,attr,omitempty"`
    Placement string `xml:"placement,attr,omitempty"`
}

type DomainNVRAM Uses

type DomainNVRAM struct {
    Alias   *DomainAlias   `xml:"alias"`
    Address *DomainAddress `xml:"address"`
}

type DomainNVRam Uses

type DomainNVRam struct {
    NVRam    string `xml:",chardata"`
    Template string `xml:"template,attr,omitempty"`
}

type DomainNuma Uses

type DomainNuma struct {
    Cell []DomainCell `xml:"cell"`
}

type DomainOS Uses

type DomainOS struct {
    Type        *DomainOSType      `xml:"type"`
    Init        string             `xml:"init,omitempty"`
    InitArgs    []string           `xml:"initarg"`
    InitEnv     []DomainOSInitEnv  `xml:"initenv"`
    InitDir     string             `xml:"initdir,omitempty"`
    InitUser    string             `xml:"inituser,omitempty"`
    InitGroup   string             `xml:"initgroup,omitempty"`
    Loader      *DomainLoader      `xml:"loader"`
    NVRam       *DomainNVRam       `xml:"nvram"`
    Kernel      string             `xml:"kernel,omitempty"`
    Initrd      string             `xml:"initrd,omitempty"`
    Cmdline     string             `xml:"cmdline,omitempty"`
    DTB         string             `xml:"dtb,omitempty"`
    ACPI        *DomainACPI        `xml:"acpi"`
    BootDevices []DomainBootDevice `xml:"boot"`
    BootMenu    *DomainBootMenu    `xml:"bootmenu"`
    BIOS        *DomainBIOS        `xml:"bios"`
    SMBios      *DomainSMBios      `xml:"smbios"`
}

type DomainOSInitEnv Uses

type DomainOSInitEnv struct {
    Name  string `xml:"name,attr"`
    Value string `xml:",chardata"`
}

type DomainOSType Uses

type DomainOSType struct {
    Arch    string `xml:"arch,attr,omitempty"`
    Machine string `xml:"machine,attr,omitempty"`
    Type    string `xml:",chardata"`
}

type DomainPM Uses

type DomainPM struct {
    SuspendToMem  *DomainPMPolicy `xml:"suspend-to-mem"`
    SuspendToDisk *DomainPMPolicy `xml:"suspend-to-disk"`
}

type DomainPMPolicy Uses

type DomainPMPolicy struct {
    Enabled string `xml:"enabled,attr"`
}

type DomainPanic Uses

type DomainPanic struct {
    XMLName xml.Name       `xml:"panic"`
    Model   string         `xml:"model,attr,omitempty"`
    Alias   *DomainAlias   `xml:"alias"`
    Address *DomainAddress `xml:"address"`
}

type DomainParallel Uses

type DomainParallel struct {
    XMLName  xml.Name               `xml:"parallel"`
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
    Target   *DomainParallelTarget  `xml:"target"`
    Log      *DomainChardevLog      `xml:"log"`
    Alias    *DomainAlias           `xml:"alias"`
    Address  *DomainAddress         `xml:"address"`
}

func (*DomainParallel) Marshal Uses

func (d *DomainParallel) Marshal() (string, error)

func (*DomainParallel) MarshalXML Uses

func (a *DomainParallel) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainParallel) Unmarshal Uses

func (d *DomainParallel) Unmarshal(doc string) error

func (*DomainParallel) UnmarshalXML Uses

func (a *DomainParallel) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainParallelTarget Uses

type DomainParallelTarget struct {
    Type string `xml:"type,attr,omitempty"`
    Port *uint  `xml:"port,attr"`
}

type DomainPerf Uses

type DomainPerf struct {
    Events []DomainPerfEvent `xml:"event"`
}

type DomainPerfEvent Uses

type DomainPerfEvent struct {
    Name    string `xml:"name,attr"`
    Enabled string `xml:"enabled,attr"`
}

type DomainQEMUCommandline Uses

type DomainQEMUCommandline struct {
    XMLName xml.Name                   `xml:"http://libvirt.org/schemas/domain/qemu/1.0 commandline"`
    Args    []DomainQEMUCommandlineArg `xml:"arg"`
    Envs    []DomainQEMUCommandlineEnv `xml:"env"`
}

type DomainQEMUCommandlineArg Uses

type DomainQEMUCommandlineArg struct {
    Value string `xml:"value,attr"`
}

type DomainQEMUCommandlineEnv Uses

type DomainQEMUCommandlineEnv struct {
    Name  string `xml:"name,attr"`
    Value string `xml:"value,attr,omitempty"`
}

type DomainRNG Uses

type DomainRNG struct {
    XMLName xml.Name          `xml:"rng"`
    Model   string            `xml:"model,attr"`
    Driver  *DomainRNGDriver  `xml:"driver"`
    Rate    *DomainRNGRate    `xml:"rate"`
    Backend *DomainRNGBackend `xml:"backend"`
    Alias   *DomainAlias      `xml:"alias"`
    Address *DomainAddress    `xml:"address"`
}

func (*DomainRNG) Marshal Uses

func (d *DomainRNG) Marshal() (string, error)

func (*DomainRNG) Unmarshal Uses

func (d *DomainRNG) Unmarshal(doc string) error

type DomainRNGBackend Uses

type DomainRNGBackend struct {
    Random *DomainRNGBackendRandom `xml:"-"`
    EGD    *DomainRNGBackendEGD    `xml:"-"`
}

func (*DomainRNGBackend) MarshalXML Uses

func (a *DomainRNGBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainRNGBackend) UnmarshalXML Uses

func (a *DomainRNGBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainRNGBackendEGD Uses

type DomainRNGBackendEGD struct {
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
}

func (*DomainRNGBackendEGD) MarshalXML Uses

func (a *DomainRNGBackendEGD) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainRNGBackendEGD) UnmarshalXML Uses

func (a *DomainRNGBackendEGD) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainRNGBackendRandom Uses

type DomainRNGBackendRandom struct {
    Device string `xml:",chardata"`
}

type DomainRNGDriver Uses

type DomainRNGDriver struct {
    IOMMU string `xml:"iommu,attr,omitempty"`
    ATS   string `xml:"ats,attr,omitempty"`
}

type DomainRNGRate Uses

type DomainRNGRate struct {
    Bytes  uint `xml:"bytes,attr"`
    Period uint `xml:"period,attr,omitempty"`
}

type DomainROM Uses

type DomainROM struct {
    Bar  string `xml:"bar,attr,omitempty"`
    File string `xml:"file,attr,omitempty"`
}

type DomainRedirDev Uses

type DomainRedirDev struct {
    XMLName  xml.Name               `xml:"redirdev"`
    Bus      string                 `xml:"bus,attr,omitempty"`
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
    Boot     *DomainDeviceBoot      `xml:"boot"`
    Alias    *DomainAlias           `xml:"alias"`
    Address  *DomainAddress         `xml:"address"`
}

func (*DomainRedirDev) Marshal Uses

func (d *DomainRedirDev) Marshal() (string, error)

func (*DomainRedirDev) MarshalXML Uses

func (a *DomainRedirDev) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainRedirDev) Unmarshal Uses

func (d *DomainRedirDev) Unmarshal(doc string) error

func (*DomainRedirDev) UnmarshalXML Uses

func (a *DomainRedirDev) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainRedirFilter Uses

type DomainRedirFilter struct {
    USB []DomainRedirFilterUSB `xml:"usbdev"`
}

type DomainRedirFilterUSB Uses

type DomainRedirFilterUSB struct {
    Class   *uint  `xml:"class,attr"`
    Vendor  *uint  `xml:"vendor,attr"`
    Product *uint  `xml:"product,attr"`
    Version string `xml:"version,attr,omitempty"`
    Allow   string `xml:"allow,attr"`
}

func (*DomainRedirFilterUSB) MarshalXML Uses

func (a *DomainRedirFilterUSB) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainRedirFilterUSB) UnmarshalXML Uses

func (a *DomainRedirFilterUSB) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainResource Uses

type DomainResource struct {
    Partition string `xml:"partition,omitempty"`
}

type DomainRoute Uses

type DomainRoute struct {
    Family  string `xml:"family,attr,omitempty"`
    Address string `xml:"address,attr,omitempty"`
    Gateway string `xml:"gateway,attr,omitempty"`
}

type DomainSMBios Uses

type DomainSMBios struct {
    Mode string `xml:"mode,attr"`
}

type DomainSecLabel Uses

type DomainSecLabel struct {
    Type       string `xml:"type,attr,omitempty"`
    Model      string `xml:"model,attr,omitempty"`
    Relabel    string `xml:"relabel,attr,omitempty"`
    Label      string `xml:"label,omitempty"`
    ImageLabel string `xml:"imagelabel,omitempty"`
    BaseLabel  string `xml:"baselabel,omitempty"`
}

type DomainSerial Uses

type DomainSerial struct {
    XMLName  xml.Name               `xml:"serial"`
    Source   *DomainChardevSource   `xml:"source"`
    Protocol *DomainChardevProtocol `xml:"protocol"`
    Target   *DomainSerialTarget    `xml:"target"`
    Log      *DomainChardevLog      `xml:"log"`
    Alias    *DomainAlias           `xml:"alias"`
    Address  *DomainAddress         `xml:"address"`
}

func (*DomainSerial) Marshal Uses

func (d *DomainSerial) Marshal() (string, error)

func (*DomainSerial) MarshalXML Uses

func (a *DomainSerial) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainSerial) Unmarshal Uses

func (d *DomainSerial) Unmarshal(doc string) error

func (*DomainSerial) UnmarshalXML Uses

func (a *DomainSerial) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainSerialTarget Uses

type DomainSerialTarget struct {
    Type  string                   `xml:"type,attr,omitempty"`
    Port  *uint                    `xml:"port,attr"`
    Model *DomainSerialTargetModel `xml:"model"`
}

type DomainSerialTargetModel Uses

type DomainSerialTargetModel struct {
    Name string `xml:"name,attr,omitempty"`
}

type DomainShmem Uses

type DomainShmem struct {
    XMLName xml.Name           `xml:"shmem"`
    Name    string             `xml:"name,attr"`
    Size    *DomainShmemSize   `xml:"size"`
    Model   *DomainShmemModel  `xml:"model"`
    Server  *DomainShmemServer `xml:"server"`
    MSI     *DomainShmemMSI    `xml:"msi"`
    Alias   *DomainAlias       `xml:"alias"`
    Address *DomainAddress     `xml:"address"`
}

func (*DomainShmem) Marshal Uses

func (d *DomainShmem) Marshal() (string, error)

func (*DomainShmem) Unmarshal Uses

func (d *DomainShmem) Unmarshal(doc string) error

type DomainShmemMSI Uses

type DomainShmemMSI struct {
    Enabled   string `xml:"enabled,attr,omitempty"`
    Vectors   uint   `xml:"vectors,attr,omitempty"`
    IOEventFD string `xml:"ioeventfd,attr,omitempty"`
}

type DomainShmemModel Uses

type DomainShmemModel struct {
    Type string `xml:"type,attr"`
}

type DomainShmemServer Uses

type DomainShmemServer struct {
    Path string `xml:"path,attr,omitempty"`
}

type DomainShmemSize Uses

type DomainShmemSize struct {
    Value uint   `xml:",chardata"`
    Unit  string `xml:"unit,attr,omitempty"`
}

type DomainSmartcard Uses

type DomainSmartcard struct {
    XMLName     xml.Name                  `xml:"smartcard"`
    Passthrough *DomainChardevSource      `xml:"source"`
    Protocol    *DomainChardevProtocol    `xml:"protocol"`
    Host        *DomainSmartcardHost      `xml:"-"`
    HostCerts   []DomainSmartcardHostCert `xml:"certificate"`
    Alias       *DomainAlias              `xml:"alias"`
    Address     *DomainAddress            `xml:"address"`
}

func (*DomainSmartcard) Marshal Uses

func (d *DomainSmartcard) Marshal() (string, error)

func (*DomainSmartcard) MarshalXML Uses

func (a *DomainSmartcard) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainSmartcard) Unmarshal Uses

func (d *DomainSmartcard) Unmarshal(doc string) error

func (*DomainSmartcard) UnmarshalXML Uses

func (a *DomainSmartcard) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainSmartcardHost Uses

type DomainSmartcardHost struct {
}

type DomainSmartcardHostCert Uses

type DomainSmartcardHostCert struct {
    File string `xml:",chardata"`
}

type DomainSnapshot Uses

type DomainSnapshot struct {
    XMLName      xml.Name              `xml:"domainsnapshot"`
    Name         string                `xml:"name,omitempty"`
    Description  string                `xml:"description,omitempty"`
    State        string                `xml:"state,omitempty"`
    CreationTime string                `xml:"creationTime,omitempty"`
    Parent       *DomainSnapshotParent `xml:"parent"`
    Memory       *DomainSnapshotMemory `xml:"memory"`
    Disks        *DomainSnapshotDisks  `xml:"disks"`
    Domain       *Domain               `xml:"domain"`
    Active       *uint                 `xml:"active"`
}

func (*DomainSnapshot) Marshal Uses

func (s *DomainSnapshot) Marshal() (string, error)

func (*DomainSnapshot) Unmarshal Uses

func (s *DomainSnapshot) Unmarshal(doc string) error

type DomainSnapshotDisk Uses

type DomainSnapshotDisk struct {
    Name     string                    `xml:"name,attr"`
    Snapshot string                    `xml:"snapshot,attr,omitempty"`
    Driver   *DomainSnapshotDiskDriver `xml:"driver"`
    Source   *DomainDiskSource         `xml:"source"`
}

func (*DomainSnapshotDisk) MarshalXML Uses

func (a *DomainSnapshotDisk) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainSnapshotDisk) UnmarshalXML Uses

func (a *DomainSnapshotDisk) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainSnapshotDiskDriver Uses

type DomainSnapshotDiskDriver struct {
    Type string `xml:"type,attr,omitempty"`
}

type DomainSnapshotDisks Uses

type DomainSnapshotDisks struct {
    Disks []DomainSnapshotDisk `xml:"disk"`
}

type DomainSnapshotMemory Uses

type DomainSnapshotMemory struct {
    Snapshot string `xml:"snapshot,attr"`
    File     string `xml:"file,attr,omitempty"`
}

type DomainSnapshotParent Uses

type DomainSnapshotParent struct {
    Name string `xml:"name"`
}

type DomainSound Uses

type DomainSound struct {
    XMLName xml.Name           `xml:"sound"`
    Model   string             `xml:"model,attr"`
    Codec   []DomainSoundCodec `xml:"codec"`
    Alias   *DomainAlias       `xml:"alias"`
    Address *DomainAddress     `xml:"address"`
}

func (*DomainSound) Marshal Uses

func (d *DomainSound) Marshal() (string, error)

func (*DomainSound) Unmarshal Uses

func (d *DomainSound) Unmarshal(doc string) error

type DomainSoundCodec Uses

type DomainSoundCodec struct {
    Type string `xml:"type,attr"`
}

type DomainSysInfo Uses

type DomainSysInfo struct {
    Type      string                   `xml:"type,attr"`
    BIOS      *DomainSysInfoBIOS       `xml:"bios"`
    System    *DomainSysInfoSystem     `xml:"system"`
    BaseBoard []DomainSysInfoBaseBoard `xml:"baseBoard"`
    Processor *DomainSysInfoProcessor  `xml:"processor"`
    Memory    *DomainSysInfoMemory     `xml:"memory"`
}

type DomainSysInfoBIOS Uses

type DomainSysInfoBIOS struct {
    Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoBaseBoard Uses

type DomainSysInfoBaseBoard struct {
    Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoEntry Uses

type DomainSysInfoEntry struct {
    Name  string `xml:"name,attr"`
    Value string `xml:",chardata"`
}

type DomainSysInfoMemory Uses

type DomainSysInfoMemory struct {
    Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoProcessor Uses

type DomainSysInfoProcessor struct {
    Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainSysInfoSystem Uses

type DomainSysInfoSystem struct {
    Entry []DomainSysInfoEntry `xml:"entry"`
}

type DomainTPM Uses

type DomainTPM struct {
    XMLName xml.Name          `xml:"tpm"`
    Model   string            `xml:"model,attr,omitempty"`
    Backend *DomainTPMBackend `xml:"backend"`
    Alias   *DomainAlias      `xml:"alias"`
    Address *DomainAddress    `xml:"address"`
}

func (*DomainTPM) Marshal Uses

func (d *DomainTPM) Marshal() (string, error)

func (*DomainTPM) Unmarshal Uses

func (d *DomainTPM) Unmarshal(doc string) error

type DomainTPMBackend Uses

type DomainTPMBackend struct {
    Passthrough *DomainTPMBackendPassthrough `xml:"-"`
}

func (*DomainTPMBackend) MarshalXML Uses

func (a *DomainTPMBackend) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*DomainTPMBackend) UnmarshalXML Uses

func (a *DomainTPMBackend) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type DomainTPMBackendDevice Uses

type DomainTPMBackendDevice struct {
    Path string `xml:"path,attr"`
}

type DomainTPMBackendPassthrough Uses

type DomainTPMBackendPassthrough struct {
    Device *DomainTPMBackendDevice `xml:"device"`
}

type DomainTimer Uses

type DomainTimer struct {
    Name       string              `xml:"name,attr"`
    Track      string              `xml:"track,attr,omitempty"`
    TickPolicy string              `xml:"tickpolicy,attr,omitempty"`
    CatchUp    *DomainTimerCatchUp `xml:"catchup"`
    Frequency  uint32              `xml:"frequency,attr,omitempty"`
    Mode       string              `xml:"mode,attr,omitempty"`
    Present    string              `xml:"present,attr,omitempty"`
}

type DomainTimerCatchUp Uses

type DomainTimerCatchUp struct {
    Threshold uint `xml:"threshold,attr,omitempty"`
    Slew      uint `xml:"slew,attr,omitempty"`
    Limit     uint `xml:"limit,attr,omitempty"`
}

type DomainVCPU Uses

type DomainVCPU struct {
    Placement string `xml:"placement,attr,omitempty"`
    CPUSet    string `xml:"cpuset,attr,omitempty"`
    Current   string `xml:"current,attr,omitempty"`
    Value     int    `xml:",chardata"`
}

type DomainVCPUs Uses

type DomainVCPUs struct {
    VCPU []DomainVCPUsVCPU `xml:"vcpu"`
}

type DomainVCPUsVCPU Uses

type DomainVCPUsVCPU struct {
    Id           *uint  `xml:"id,attr"`
    Enabled      string `xml:"enabled,attr,omitempty"`
    Hotpluggable string `xml:"hotpluggable,attr,omitempty"`
    Order        *uint  `xml:"order,attr"`
}

type DomainVMWareDataCenterPath Uses

type DomainVMWareDataCenterPath struct {
    XMLName xml.Name `xml:"http://libvirt.org/schemas/domain/vmware/1.0 datacenterpath"`
    Value   string   `xml:",chardata"`
}

type DomainVideo Uses

type DomainVideo struct {
    XMLName xml.Name           `xml:"video"`
    Model   DomainVideoModel   `xml:"model"`
    Driver  *DomainVideoDriver `xml:"driver"`
    Alias   *DomainAlias       `xml:"alias"`
    Address *DomainAddress     `xml:"address"`
}

func (*DomainVideo) Marshal Uses

func (d *DomainVideo) Marshal() (string, error)

func (*DomainVideo) Unmarshal Uses

func (d *DomainVideo) Unmarshal(doc string) error

type DomainVideoAccel Uses

type DomainVideoAccel struct {
    Accel3D string `xml:"accel3d,attr,omitempty"`
    Accel2D string `xml:"accel2d,attr,omitempty"`
}

type DomainVideoDriver Uses

type DomainVideoDriver struct {
    VGAConf string `xml:"vgaconf,attr,omitempty"`
    IOMMU   string `xml:"iommu,attr,omitempty"`
    ATS     string `xml:"ats,attr,omitempty"`
}

type DomainVideoModel Uses

type DomainVideoModel struct {
    Type    string            `xml:"type,attr"`
    Heads   uint              `xml:"heads,attr,omitempty"`
    Ram     uint              `xml:"ram,attr,omitempty"`
    VRam    uint              `xml:"vram,attr,omitempty"`
    VRam64  uint              `xml:"vram64,attr,omitempty"`
    VGAMem  uint              `xml:"vgamem,attr,omitempty"`
    Primary string            `xml:"primary,attr,omitempty"`
    Accel   *DomainVideoAccel `xml:"acceleration"`
}

type DomainWatchdog Uses

type DomainWatchdog struct {
    XMLName xml.Name       `xml:"watchdog"`
    Model   string         `xml:"model,attr"`
    Action  string         `xml:"action,attr,omitempty"`
    Alias   *DomainAlias   `xml:"alias"`
    Address *DomainAddress `xml:"address"`
}

func (*DomainWatchdog) Marshal Uses

func (d *DomainWatchdog) Marshal() (string, error)

func (*DomainWatchdog) Unmarshal Uses

func (d *DomainWatchdog) Unmarshal(doc string) error

type Interface Uses

type Interface struct {
    XMLName  xml.Name            `xml:"interface"`
    Name     string              `xml:"name,attr,omitempty"`
    Start    *InterfaceStart     `xml:"start"`
    MTU      *InterfaceMTU       `xml:"mtu"`
    Protocol []InterfaceProtocol `xml:"protocol"`
    Link     *InterfaceLink      `xml:"link"`
    MAC      *InterfaceMAC       `xml:"mac"`
    Bond     *InterfaceBond      `xml:"bond"`
    Bridge   *InterfaceBridge    `xml:"bridge"`
    VLAN     *InterfaceVLAN      `xml:"vlan"`
}

func (*Interface) Marshal Uses

func (s *Interface) Marshal() (string, error)

func (*Interface) MarshalXML Uses

func (s *Interface) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*Interface) Unmarshal Uses

func (s *Interface) Unmarshal(doc string) error

type InterfaceAutoConf Uses

type InterfaceAutoConf struct {
}

type InterfaceBond Uses

type InterfaceBond struct {
    Mode       string               `xml:"mode,attr,omitempty"`
    ARPMon     *InterfaceBondARPMon `xml:"arpmon"`
    MIIMon     *InterfaceBondMIIMon `xml:"miimon"`
    Interfaces []Interface          `xml:"interface"`
}

type InterfaceBondARPMon Uses

type InterfaceBondARPMon struct {
    Interval uint   `xml:"interval,attr,omitempty"`
    Target   string `xml:"target,attr,omitempty"`
    Validate string `xml:"validate,attr,omitempty"`
}

type InterfaceBondMIIMon Uses

type InterfaceBondMIIMon struct {
    Freq    uint   `xml:"freq,attr,omitempty"`
    UpDelay uint   `xml:"updelay,attr,omitempty"`
    Carrier string `xml:"carrier,attr,omitempty"`
}

type InterfaceBridge Uses

type InterfaceBridge struct {
    STP        string      `xml:"stp,attr,omitempty"`
    Delay      *float64    `xml:"delay,attr"`
    Interfaces []Interface `xml:"interface"`
}

type InterfaceDHCP Uses

type InterfaceDHCP struct {
    PeerDNS string `xml:"peerdns,attr,omitempty"`
}

type InterfaceIP Uses

type InterfaceIP struct {
    Address string `xml:"address,attr"`
    Prefix  uint   `xml:"prefix,attr,omitempty"`
}
type InterfaceLink struct {
    Speed uint   `xml:"speed,attr,omitempty"`
    State string `xml:"state,attr,omitempty"`
}

type InterfaceMAC Uses

type InterfaceMAC struct {
    Address string `xml:"address,attr"`
}

type InterfaceMTU Uses

type InterfaceMTU struct {
    Size uint `xml:"size,attr"`
}

type InterfaceProtocol Uses

type InterfaceProtocol struct {
    Family   string             `xml:"family,attr,omitempty"`
    AutoConf *InterfaceAutoConf `xml:"autoconf"`
    DHCP     *InterfaceDHCP     `xml:"dhcp"`
    IPs      []InterfaceIP      `xml:"ip"`
    Route    []InterfaceRoute   `xml:"route"`
}

type InterfaceRoute Uses

type InterfaceRoute struct {
    Gateway string `xml:"gateway,attr"`
}

type InterfaceStart Uses

type InterfaceStart struct {
    Mode string `xml:"mode,attr"`
}

type InterfaceVLAN Uses

type InterfaceVLAN struct {
    Tag       *uint      `xml:"tag,attr"`
    Interface *Interface `xml:"interface"`
}

type NWFilter Uses

type NWFilter struct {
    XMLName  xml.Name `xml:"filter"`
    Name     string   `xml:"name,attr"`
    UUID     string   `xml:"uuid,omitempty"`
    Chain    string   `xml:"chain,attr,omitempty"`
    Priority int      `xml:"priority,attr,omitempty"`
    Entries  []NWFilterEntry
}

func (*NWFilter) Marshal Uses

func (s *NWFilter) Marshal() (string, error)

func (*NWFilter) MarshalXML Uses

func (a *NWFilter) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NWFilter) Unmarshal Uses

func (s *NWFilter) Unmarshal(doc string) error

func (*NWFilter) UnmarshalXML Uses

func (a *NWFilter) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NWFilterEntry Uses

type NWFilterEntry struct {
    Rule *NWFilterRule
    Ref  *NWFilterRef
}

type NWFilterField Uses

type NWFilterField struct {
    Var  string
    Str  string
    Uint *uint
}

func (*NWFilterField) MarshalXMLAttr Uses

func (s *NWFilterField) MarshalXMLAttr(name xml.Name) (xml.Attr, error)

func (*NWFilterField) UnmarshalXMLAttr Uses

func (s *NWFilterField) UnmarshalXMLAttr(attr xml.Attr) error

type NWFilterParameter Uses

type NWFilterParameter struct {
    Name  string `xml:"name,attr"`
    Value string `xml:"value,attr"`
}

type NWFilterRef Uses

type NWFilterRef struct {
    Filter     string              `xml:"filter,attr"`
    Parameters []NWFilterParameter `xml:"parameter"`
}

type NWFilterRule Uses

type NWFilterRule struct {
    Action     string `xml:"action,attr,omitempty"`
    Direction  string `xml:"direction,attr,omitempty"`
    Priority   int    `xml:"priority,attr,omitempty"`
    StateMatch string `xml:"statematch,attr,omitempty"`

    ARP         *NWFilterRuleARP         `xml:"arp"`
    RARP        *NWFilterRuleRARP        `xml:"rarp"`
    MAC         *NWFilterRuleMAC         `xml:"mac"`
    VLAN        *NWFilterRuleVLAN        `xml:"vlan"`
    STP         *NWFilterRuleSTP         `xml:"stp"`
    IP          *NWFilterRuleIP          `xml:"ip"`
    IPv6        *NWFilterRuleIPv6        `xml:"ipv6"`
    TCP         *NWFilterRuleTCP         `xml:"tcp"`
    UDP         *NWFilterRuleUDP         `xml:"udp"`
    UDPLite     *NWFilterRuleUDPLite     `xml:"udplite"`
    ESP         *NWFilterRuleESP         `xml:"esp"`
    AH          *NWFilterRuleAH          `xml:"ah"`
    SCTP        *NWFilterRuleSCTP        `xml:"sctp"`
    ICMP        *NWFilterRuleICMP        `xml:"icmp"`
    All         *NWFilterRuleAll         `xml:"all"`
    IGMP        *NWFilterRuleIGMP        `xml:"igmp"`
    TCPIPv6     *NWFilterRuleTCPIPv6     `xml:"tcp-ipv6"`
    UDPIPv6     *NWFilterRuleUDPIPv6     `xml:"udp-ipv6"`
    UDPLiteIPv6 *NWFilterRuleUDPLiteIPv6 `xml:"udplite-ipv6"`
    ESPIPv6     *NWFilterRuleESPIPv6     `xml:"esp-ipv6"`
    AHIPv6      *NWFilterRuleAHIPv6      `xml:"ah-ipv6"`
    SCTPIPv6    *NWFilterRuleSCTPIPv6    `xml:"sctp-ipv6"`
    ICMPv6      *NWFilterRuleICMPIPv6    `xml:"icmpv6"`
    AllIPv6     *NWFilterRuleAllIPv6     `xml:"all-ipv6"`
}

type NWFilterRuleAH Uses

type NWFilterRuleAH struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAHIPv6 Uses

type NWFilterRuleAHIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleARP Uses

type NWFilterRuleARP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    HWType        NWFilterField `xml:"hwtype,attr"`
    ProtocolType  NWFilterField `xml:"protocoltype,attr"`
    OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
    ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
    ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
    ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
    ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
    ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
    ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
    Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
    Comment       string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAll Uses

type NWFilterRuleAll struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleAllIPv6 Uses

type NWFilterRuleAllIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleCommonIP Uses

type NWFilterRuleCommonIP struct {
    SrcMACAddr     NWFilterField `xml:"srcmacaddr,attr,omitempty"`
    SrcIPAddr      NWFilterField `xml:"srcipaddr,attr,omitempty"`
    SrcIPMask      NWFilterField `xml:"srcipmask,attr,omitempty"`
    DstIPAddr      NWFilterField `xml:"dstipaddr,attr,omitempty"`
    DstIPMask      NWFilterField `xml:"dstipmask,attr,omitempty"`
    SrcIPFrom      NWFilterField `xml:"srcipfrom,attr,omitempty"`
    SrcIPTo        NWFilterField `xml:"srcipto,attr,omitempty"`
    DstIPFrom      NWFilterField `xml:"dstipfrom,attr,omitempty"`
    DstIPTo        NWFilterField `xml:"dstipto,attr,omitempty"`
    DSCP           NWFilterField `xml:"dscp,attr"`
    ConnLimitAbove NWFilterField `xml:"connlimit-above,attr"`
    State          NWFilterField `xml:"state,attr,omitempty"`
    IPSet          NWFilterField `xml:"ipset,attr,omitempty"`
    IPSetFlags     NWFilterField `xml:"ipsetflags,attr,omitempty"`
}

type NWFilterRuleCommonMAC Uses

type NWFilterRuleCommonMAC struct {
    SrcMACAddr NWFilterField `xml:"srcmacaddr,attr,omitempty"`
    SrcMACMask NWFilterField `xml:"srcmacmask,attr,omitempty"`
    DstMACAddr NWFilterField `xml:"dstmacaddr,attr,omitempty"`
    DstMACMask NWFilterField `xml:"dstmacmask,attr,omitempty"`
}

type NWFilterRuleCommonPort Uses

type NWFilterRuleCommonPort struct {
    SrcPortStart NWFilterField `xml:"srcportstart,attr"`
    SrcPortEnd   NWFilterField `xml:"srcportend,attr"`
    DstPortStart NWFilterField `xml:"dstportstart,attr"`
    DstPortEnd   NWFilterField `xml:"dstportend,attr"`
}

type NWFilterRuleESP Uses

type NWFilterRuleESP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleESPIPv6 Uses

type NWFilterRuleESPIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleICMP Uses

type NWFilterRuleICMP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Type    NWFilterField `xml:"type,attr"`
    Code    NWFilterField `xml:"code,attr"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleICMPIPv6 Uses

type NWFilterRuleICMPIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Type    NWFilterField `xml:"type,attr"`
    Code    NWFilterField `xml:"code,attr"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIGMP Uses

type NWFilterRuleIGMP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIP Uses

type NWFilterRuleIP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
    SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
    DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
    DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
    Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
    NWFilterRuleCommonPort
    DSCP    NWFilterField `xml:"dscp,attr"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleIPv6 Uses

type NWFilterRuleIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    SrcIPAddr NWFilterField `xml:"srcipaddr,attr,omitempty"`
    SrcIPMask NWFilterField `xml:"srcipmask,attr,omitempty"`
    DstIPAddr NWFilterField `xml:"dstipaddr,attr,omitempty"`
    DstIPMask NWFilterField `xml:"dstipmask,attr,omitempty"`
    Protocol  NWFilterField `xml:"protocol,attr,omitempty"`
    NWFilterRuleCommonPort
    Type    NWFilterField `xml:"type,attr"`
    TypeEnd NWFilterField `xml:"typeend,attr"`
    Code    NWFilterField `xml:"code,attr"`
    CodeEnd NWFilterField `xml:"codeend,attr"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleMAC Uses

type NWFilterRuleMAC struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    ProtocolID NWFilterField `xml:"protocolid,attr,omitempty"`
    Comment    string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleRARP Uses

type NWFilterRuleRARP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    HWType        NWFilterField `xml:"hwtype,attr"`
    ProtocolType  NWFilterField `xml:"protocoltype,attr"`
    OpCode        NWFilterField `xml:"opcode,attr,omitempty"`
    ARPSrcMACAddr NWFilterField `xml:"arpsrcmacaddr,attr,omitempty"`
    ARPDstMACAddr NWFilterField `xml:"arpdstmacaddr,attr,omitempty"`
    ARPSrcIPAddr  NWFilterField `xml:"arpsrcipaddr,attr,omitempty"`
    ARPSrcIPMask  NWFilterField `xml:"arpsrcipmask,attr,omitempty"`
    ARPDstIPAddr  NWFilterField `xml:"arpdstipaddr,attr,omitempty"`
    ARPDstIPMask  NWFilterField `xml:"arpdstipmask,attr,omitempty"`
    Gratuitous    NWFilterField `xml:"gratuitous,attr,omitempty"`
    Comment       string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSCTP Uses

type NWFilterRuleSCTP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSCTPIPv6 Uses

type NWFilterRuleSCTPIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleSTP Uses

type NWFilterRuleSTP struct {
    Match             NWFilterField `xml:"match,attr,omitempty"`
    SrcMACAddr        NWFilterField `xml:"srcmacaddr,attr,omitempty"`
    SrcMACMask        NWFilterField `xml:"srcmacmask,attr,omitempty"`
    Type              NWFilterField `xml:"type,attr"`
    Flags             NWFilterField `xml:"flags,attr"`
    RootPriority      NWFilterField `xml:"root-priority,attr"`
    RootPriorityHi    NWFilterField `xml:"root-priority-hi,attr"`
    RootAddress       NWFilterField `xml:"root-address,attr,omitempty"`
    RootAddressMask   NWFilterField `xml:"root-address-mask,attr,omitempty"`
    RootCost          NWFilterField `xml:"root-cost,attr"`
    RootCostHi        NWFilterField `xml:"root-cost-hi,attr"`
    SenderPriority    NWFilterField `xml:"sender-priority,attr"`
    SenderPriorityHi  NWFilterField `xml:"sender-priority-hi,attr"`
    SenderAddress     NWFilterField `xml:"sender-address,attr,omitempty"`
    SenderAddressMask NWFilterField `xml:"sender-address-mask,attr,omitempty"`
    Port              NWFilterField `xml:"port,attr"`
    PortHi            NWFilterField `xml:"port-hi,attr"`
    Age               NWFilterField `xml:"age,attr"`
    AgeHi             NWFilterField `xml:"age-hi,attr"`
    MaxAge            NWFilterField `xml:"max-age,attr"`
    MaxAgeHi          NWFilterField `xml:"max-age-hi,attr"`
    HelloTime         NWFilterField `xml:"hello-time,attr"`
    HelloTimeHi       NWFilterField `xml:"hello-time-hi,attr"`
    ForwardDelay      NWFilterField `xml:"forward-delay,attr"`
    ForwardDelayHi    NWFilterField `xml:"forward-delay-hi,attr"`
    Comment           string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleTCP Uses

type NWFilterRuleTCP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Option  NWFilterField `xml:"option,attr"`
    Flags   NWFilterField `xml:"flags,attr,omitempty"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleTCPIPv6 Uses

type NWFilterRuleTCPIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Option  NWFilterField `xml:"option,attr"`
    Comment string        `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDP Uses

type NWFilterRuleUDP struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPIPv6 Uses

type NWFilterRuleUDPIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    NWFilterRuleCommonPort
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPLite Uses

type NWFilterRuleUDPLite struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleUDPLiteIPv6 Uses

type NWFilterRuleUDPLiteIPv6 struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonIP
    Comment string `xml:"comment,attr,omitempty"`
}

type NWFilterRuleVLAN Uses

type NWFilterRuleVLAN struct {
    Match string `xml:"match,attr,omitempty"`
    NWFilterRuleCommonMAC
    VLANID        NWFilterField `xml:"vlanid,attr,omitempty"`
    EncapProtocol NWFilterField `xml:"encap-protocol,attr,omitempty"`
    Comment       string        `xml:"comment,attr,omitempty"`
}

type Network Uses

type Network struct {
    XMLName             xml.Name            `xml:"network"`
    IPv6                string              `xml:"ipv6,attr,omitempty"`
    TrustGuestRxFilters string              `xml:"trustGuestRxFilters,attr,omitempty"`
    Name                string              `xml:"name,omitempty"`
    UUID                string              `xml:"uuid,omitempty"`
    Metadata            *NetworkMetadata    `xml:"metadata"`
    Forward             *NetworkForward     `xml:"forward"`
    Bridge              *NetworkBridge      `xml:"bridge"`
    MTU                 *NetworkMTU         `xml:"mtu"`
    MAC                 *NetworkMAC         `xml:"mac"`
    Domain              *NetworkDomain      `xml:"domain"`
    DNS                 *NetworkDNS         `xml:"dns"`
    VLAN                *NetworkVLAN        `xml:"vlan"`
    Bandwidth           *NetworkBandwidth   `xml:"bandwidth"`
    IPs                 []NetworkIP         `xml:"ip"`
    Routes              []NetworkRoute      `xml:"route"`
    VirtualPort         *NetworkVirtualPort `xml:"virtualport"`
    PortGroups          []NetworkPortGroup  `xml:"portgroup"`
}

func (*Network) Marshal Uses

func (s *Network) Marshal() (string, error)

func (*Network) Unmarshal Uses

func (s *Network) Unmarshal(doc string) error

type NetworkBandwidth Uses

type NetworkBandwidth struct {
    Inbound  *NetworkBandwidthParams `xml:"inbound"`
    Outbound *NetworkBandwidthParams `xml:"outbound"`
}

type NetworkBandwidthParams Uses

type NetworkBandwidthParams struct {
    Average *uint `xml:"average,attr"`
    Peak    *uint `xml:"peak,attr"`
    Burst   *uint `xml:"burst,attr"`
    Floor   *uint `xml:"floor,attr"`
}

type NetworkBootp Uses

type NetworkBootp struct {
    File   string `xml:"file,attr,omitempty"`
    Server string `xml:"server,attr,omitempty"`
}

type NetworkBridge Uses

type NetworkBridge struct {
    Name            string `xml:"name,attr,omitempty"`
    STP             string `xml:"stp,attr,omitempty"`
    Delay           string `xml:"delay,attr,omitempty"`
    MACTableManager string `xml:"macTableManager,attr,omitempty"`
}

type NetworkDHCP Uses

type NetworkDHCP struct {
    Ranges []NetworkDHCPRange `xml:"range"`
    Hosts  []NetworkDHCPHost  `xml:"host"`
    Bootp  []NetworkBootp     `xml:"bootp"`
}

type NetworkDHCPHost Uses

type NetworkDHCPHost struct {
    XMLName xml.Name `xml:"host"`
    ID      string   `xml:"id,attr,omitempty"`
    MAC     string   `xml:"mac,attr,omitempty"`
    Name    string   `xml:"name,attr,omitempty"`
    IP      string   `xml:"ip,attr,omitempty"`
}

func (*NetworkDHCPHost) Marshal Uses

func (s *NetworkDHCPHost) Marshal() (string, error)

func (*NetworkDHCPHost) Unmarshal Uses

func (s *NetworkDHCPHost) Unmarshal(doc string) error

type NetworkDHCPRange Uses

type NetworkDHCPRange struct {
    XMLName xml.Name `xml:"range"`
    Start   string   `xml:"start,attr,omitempty"`
    End     string   `xml:"end,attr,omitempty"`
}

func (*NetworkDHCPRange) Marshal Uses

func (s *NetworkDHCPRange) Marshal() (string, error)

func (*NetworkDHCPRange) Unmarshal Uses

func (s *NetworkDHCPRange) Unmarshal(doc string) error

type NetworkDNS Uses

type NetworkDNS struct {
    Enable            string                `xml:"enable,attr,omitempty"`
    ForwardPlainNames string                `xml:"forwardPlainNames,attr,omitempty"`
    Forwarders        []NetworkDNSForwarder `xml:"forwarder"`
    TXTs              []NetworkDNSTXT       `xml:"txt"`
    Host              []NetworkDNSHost      `xml:"host"`
    SRVs              []NetworkDNSSRV       `xml:"srv"`
}

type NetworkDNSForwarder Uses

type NetworkDNSForwarder struct {
    Domain string `xml:"domain,attr,omitempty"`
    Addr   string `xml:"addr,attr,omitempty"`
}

type NetworkDNSHost Uses

type NetworkDNSHost struct {
    XMLName   xml.Name                 `xml:"host"`
    IP        string                   `xml:"ip,attr"`
    Hostnames []NetworkDNSHostHostname `xml:"hostname"`
}

func (*NetworkDNSHost) Marshal Uses

func (s *NetworkDNSHost) Marshal() (string, error)

func (*NetworkDNSHost) Unmarshal Uses

func (s *NetworkDNSHost) Unmarshal(doc string) error

type NetworkDNSHostHostname Uses

type NetworkDNSHostHostname struct {
    Hostname string `xml:",chardata"`
}

type NetworkDNSSRV Uses

type NetworkDNSSRV struct {
    XMLName  xml.Name `xml:"srv"`
    Service  string   `xml:"service,attr,omitempty"`
    Protocol string   `xml:"protocol,attr,omitempty"`
    Target   string   `xml:"target,attr,omitempty"`
    Port     uint     `xml:"port,attr,omitempty"`
    Priority uint     `xml:"priority,attr,omitempty"`
    Weight   uint     `xml:"weight,attr,omitempty"`
    Domain   string   `xml:"domain,attr,omitempty"`
}

func (*NetworkDNSSRV) Marshal Uses

func (s *NetworkDNSSRV) Marshal() (string, error)

func (*NetworkDNSSRV) Unmarshal Uses

func (s *NetworkDNSSRV) Unmarshal(doc string) error

type NetworkDNSTXT Uses

type NetworkDNSTXT struct {
    XMLName xml.Name `xml:"txt"`
    Name    string   `xml:"name,attr"`
    Value   string   `xml:"value,attr"`
}

func (*NetworkDNSTXT) Marshal Uses

func (s *NetworkDNSTXT) Marshal() (string, error)

func (*NetworkDNSTXT) Unmarshal Uses

func (s *NetworkDNSTXT) Unmarshal(doc string) error

type NetworkDomain Uses

type NetworkDomain struct {
    Name      string `xml:"name,attr,omitempty"`
    LocalOnly string `xml:"localOnly,attr,omitempty"`
}

type NetworkForward Uses

type NetworkForward struct {
    Mode       string                    `xml:"mode,attr,omitempty"`
    Dev        string                    `xml:"dev,attr,omitempty"`
    Managed    string                    `xml:"managed,attr,omitempty"`
    Driver     *NetworkForwardDriver     `xml:"driver"`
    PFs        []NetworkForwardPF        `xml:"pf"`
    NAT        *NetworkForwardNAT        `xml:"nat"`
    Interfaces []NetworkForwardInterface `xml:"interface"`
    Addresses  []NetworkForwardAddress   `xml:"address"`
}

type NetworkForwardAddress Uses

type NetworkForwardAddress struct {
    PCI *NetworkForwardAddressPCI `xml:"-"`
}

func (*NetworkForwardAddress) MarshalXML Uses

func (a *NetworkForwardAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkForwardAddress) UnmarshalXML Uses

func (a *NetworkForwardAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkForwardAddressPCI Uses

type NetworkForwardAddressPCI struct {
    Domain   *uint `xml:"domain,attr"`
    Bus      *uint `xml:"bus,attr"`
    Slot     *uint `xml:"slot,attr"`
    Function *uint `xml:"function,attr"`
}

func (*NetworkForwardAddressPCI) MarshalXML Uses

func (a *NetworkForwardAddressPCI) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkForwardAddressPCI) UnmarshalXML Uses

func (a *NetworkForwardAddressPCI) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkForwardDriver Uses

type NetworkForwardDriver struct {
    Name string `xml:"name,attr"`
}

type NetworkForwardInterface Uses

type NetworkForwardInterface struct {
    XMLName xml.Name `xml:"interface"`
    Dev     string   `xml:"dev,attr,omitempty"`
}

func (*NetworkForwardInterface) Marshal Uses

func (s *NetworkForwardInterface) Marshal() (string, error)

func (*NetworkForwardInterface) Unmarshal Uses

func (s *NetworkForwardInterface) Unmarshal(doc string) error

type NetworkForwardNAT Uses

type NetworkForwardNAT struct {
    Addresses []NetworkForwardNATAddress `xml:"address"`
    Ports     []NetworkForwardNATPort    `xml:"port"`
}

type NetworkForwardNATAddress Uses

type NetworkForwardNATAddress struct {
    Start string `xml:"start,attr"`
    End   string `xml:"end,attr"`
}

type NetworkForwardNATPort Uses

type NetworkForwardNATPort struct {
    Start uint `xml:"start,attr"`
    End   uint `xml:"end,attr"`
}

type NetworkForwardPF Uses

type NetworkForwardPF struct {
    Dev string `xml:"dev,attr"`
}

type NetworkIP Uses

type NetworkIP struct {
    Address  string       `xml:"address,attr,omitempty"`
    Family   string       `xml:"family,attr,omitempty"`
    Netmask  string       `xml:"netmask,attr,omitempty"`
    Prefix   uint         `xml:"prefix,attr,omitempty"`
    LocalPtr string       `xml:"localPtr,attr,omitempty"`
    DHCP     *NetworkDHCP `xml:"dhcp"`
    TFTP     *NetworkTFTP `xml:"tftp"`
}

type NetworkMAC Uses

type NetworkMAC struct {
    Address string `xml:"address,attr,omitempty"`
}

type NetworkMTU Uses

type NetworkMTU struct {
    Size uint `xml:"size,attr"`
}

type NetworkMetadata Uses

type NetworkMetadata struct {
    XML string `xml:",innerxml"`
}

type NetworkPortGroup Uses

type NetworkPortGroup struct {
    XMLName             xml.Name            `xml:"portgroup"`
    Name                string              `xml:"name,attr,omitempty"`
    Default             string              `xml:"default,attr,omitempty"`
    TrustGuestRxFilters string              `xml:"trustGuestRxFilters,attr,omitempty"`
    VLAN                *NetworkVLAN        `xml:"vlan"`
    VirtualPort         *NetworkVirtualPort `xml:"virtualport"`
}

func (*NetworkPortGroup) Marshal Uses

func (s *NetworkPortGroup) Marshal() (string, error)

func (*NetworkPortGroup) Unmarshal Uses

func (s *NetworkPortGroup) Unmarshal(doc string) error

type NetworkRoute Uses

type NetworkRoute struct {
    Family  string `xml:"family,attr,omitempty"`
    Address string `xml:"address,attr,omitempty"`
    Netmask string `xml:"netmask,attr,omitempty"`
    Prefix  uint   `xml:"prefix,attr,omitempty"`
    Gateway string `xml:"gateway,attr,omitempty"`
    Metric  string `xml:"metric,attr,omitempty"`
}

type NetworkTFTP Uses

type NetworkTFTP struct {
    Root string `xml:"root,attr,omitempty"`
}

type NetworkVLAN Uses

type NetworkVLAN struct {
    Trunk string           `xml:"trunk,attr,omitempty"`
    Tags  []NetworkVLANTag `xml:"tag"`
}

type NetworkVLANTag Uses

type NetworkVLANTag struct {
    ID         uint   `xml:"id,attr"`
    NativeMode string `xml:"nativeMode,attr,omitempty"`
}

type NetworkVirtualPort Uses

type NetworkVirtualPort struct {
    Params *NetworkVirtualPortParams `xml:"parameters"`
}

func (*NetworkVirtualPort) MarshalXML Uses

func (a *NetworkVirtualPort) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkVirtualPort) UnmarshalXML Uses

func (a *NetworkVirtualPort) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkVirtualPortParams Uses

type NetworkVirtualPortParams struct {
    Any          *NetworkVirtualPortParamsAny          `xml:"-"`
    VEPA8021QBG  *NetworkVirtualPortParamsVEPA8021QBG  `xml:"-"`
    VNTag8011QBH *NetworkVirtualPortParamsVNTag8021QBH `xml:"-"`
    OpenVSwitch  *NetworkVirtualPortParamsOpenVSwitch  `xml:"-"`
    MidoNet      *NetworkVirtualPortParamsMidoNet      `xml:"-"`
}

func (*NetworkVirtualPortParams) MarshalXML Uses

func (a *NetworkVirtualPortParams) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NetworkVirtualPortParams) UnmarshalXML Uses

func (a *NetworkVirtualPortParams) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NetworkVirtualPortParamsAny Uses

type NetworkVirtualPortParamsAny struct {
    ManagerID     *uint  `xml:"managerid,attr"`
    TypeID        *uint  `xml:"typeid,attr"`
    TypeIDVersion *uint  `xml:"typeidversion,attr"`
    InstanceID    string `xml:"instanceid,attr,omitempty"`
    ProfileID     string `xml:"profileid,attr,omitempty"`
    InterfaceID   string `xml:"interfaceid,attr,omitempty"`
}

type NetworkVirtualPortParamsMidoNet Uses

type NetworkVirtualPortParamsMidoNet struct {
    InterfaceID string `xml:"interfaceid,attr,omitempty"`
}

type NetworkVirtualPortParamsOpenVSwitch Uses

type NetworkVirtualPortParamsOpenVSwitch struct {
    InterfaceID string `xml:"interfaceid,attr,omitempty"`
    ProfileID   string `xml:"profileid,attr,omitempty"`
}

type NetworkVirtualPortParamsVEPA8021QBG Uses

type NetworkVirtualPortParamsVEPA8021QBG struct {
    ManagerID     *uint  `xml:"managerid,attr"`
    TypeID        *uint  `xml:"typeid,attr"`
    TypeIDVersion *uint  `xml:"typeidversion,attr"`
    InstanceID    string `xml:"instanceid,attr,omitempty"`
}

type NetworkVirtualPortParamsVNTag8021QBH Uses

type NetworkVirtualPortParamsVNTag8021QBH struct {
    ProfileID string `xml:"profileid,attr,omitempty"`
}

type NodeDevice Uses

type NodeDevice struct {
    XMLName    xml.Name             `xml:"device"`
    Name       string               `xml:"name"`
    Path       string               `xml:"path,omitempty"`
    DevNodes   []NodeDeviceDevNode  `xml:"devnode"`
    Parent     string               `xml:"parent,omitempty"`
    Driver     *NodeDeviceDriver    `xml:"driver"`
    Capability NodeDeviceCapability `xml:"capability"`
}

func (*NodeDevice) Marshal Uses

func (c *NodeDevice) Marshal() (string, error)

func (*NodeDevice) Unmarshal Uses

func (c *NodeDevice) Unmarshal(doc string) error

type NodeDeviceCCWCapability Uses

type NodeDeviceCCWCapability struct {
    CSSID *uint `xml:"cssid"`
    SSID  *uint `xml:"ssid"`
    DevNo *uint `xml:"devno"`
}

func (*NodeDeviceCCWCapability) MarshalXML Uses

func (c *NodeDeviceCCWCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCCWCapability) UnmarshalXML Uses

func (c *NodeDeviceCCWCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceCapability Uses

type NodeDeviceCapability struct {
    System     *NodeDeviceSystemCapability
    PCI        *NodeDevicePCICapability
    USB        *NodeDeviceUSBCapability
    USBDevice  *NodeDeviceUSBDeviceCapability
    Net        *NodeDeviceNetCapability
    SCSIHost   *NodeDeviceSCSIHostCapability
    SCSITarget *NodeDeviceSCSITargetCapability
    SCSI       *NodeDeviceSCSICapability
    Storage    *NodeDeviceStorageCapability
    DRM        *NodeDeviceDRMCapability
    CCW        *NodeDeviceCCWCapability
    MDev       *NodeDeviceMDevCapability
}

func (*NodeDeviceCapability) MarshalXML Uses

func (c *NodeDeviceCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceCapability) UnmarshalXML Uses

func (c *NodeDeviceCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceDRMCapability Uses

type NodeDeviceDRMCapability struct {
    Type string `xml:"type"`
}

type NodeDeviceDevNode Uses

type NodeDeviceDevNode struct {
    Type string `xml:"type,attr,omitempty"`
    Path string `xml:",chardata"`
}

type NodeDeviceDriver Uses

type NodeDeviceDriver struct {
    Name string `xml:"name"`
}

type NodeDeviceIDName Uses

type NodeDeviceIDName struct {
    ID   string `xml:"id,attr"`
    Name string `xml:",chardata"`
}

type NodeDeviceIOMMUGroup Uses

type NodeDeviceIOMMUGroup struct {
    Number  int                    `xml:"number,attr"`
    Address []NodeDevicePCIAddress `xml:"address"`
}

type NodeDeviceMDevCapability Uses

type NodeDeviceMDevCapability struct {
    Type       *NodeDeviceMDevCapabilityType `xml:"type"`
    IOMMUGroup *NodeDeviceIOMMUGroup         `xml:"iommuGroup"`
}

type NodeDeviceMDevCapabilityType Uses

type NodeDeviceMDevCapabilityType struct {
    ID string `xml:"id,attr"`
}

type NodeDeviceNUMA Uses

type NodeDeviceNUMA struct {
    Node int `xml:"node,attr"`
}

type NodeDeviceNet80203Capability Uses

type NodeDeviceNet80203Capability struct {
}

type NodeDeviceNet80211Capability Uses

type NodeDeviceNet80211Capability struct {
}

type NodeDeviceNetCapability Uses

type NodeDeviceNetCapability struct {
    Interface  string                         `xml:"interface"`
    Address    string                         `xml:"address"`
    Link       *NodeDeviceNetLink             `xml:"link"`
    Features   []NodeDeviceNetOffloadFeatures `xml:"feature,omitempty"`
    Capability []NodeDeviceNetSubCapability   `xml:"capability"`
}
type NodeDeviceNetLink struct {
    State string `xml:"state,attr"`
    Speed string `xml:"speed,attr,omitempty"`
}

type NodeDeviceNetOffloadFeatures Uses

type NodeDeviceNetOffloadFeatures struct {
    Name string `xml:"name,attr"`
}

type NodeDeviceNetSubCapability Uses

type NodeDeviceNetSubCapability struct {
    Wireless80211 *NodeDeviceNet80211Capability
    Ethernet80203 *NodeDeviceNet80203Capability
}

func (*NodeDeviceNetSubCapability) MarshalXML Uses

func (c *NodeDeviceNetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceNetSubCapability) UnmarshalXML Uses

func (c *NodeDeviceNetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIAddress Uses

type NodeDevicePCIAddress struct {
    Domain   *uint `xml:"domain,attr"`
    Bus      *uint `xml:"bus,attr"`
    Slot     *uint `xml:"slot,attr"`
    Function *uint `xml:"function,attr"`
}

func (*NodeDevicePCIAddress) MarshalXML Uses

func (a *NodeDevicePCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDevicePCIAddress) UnmarshalXML Uses

func (a *NodeDevicePCIAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIBridgeCapability Uses

type NodeDevicePCIBridgeCapability struct {
}

type NodeDevicePCICapability Uses

type NodeDevicePCICapability struct {
    Domain       *uint                        `xml:"domain"`
    Bus          *uint                        `xml:"bus"`
    Slot         *uint                        `xml:"slot"`
    Function     *uint                        `xml:"function"`
    Product      NodeDeviceIDName             `xml:"product,omitempty"`
    Vendor       NodeDeviceIDName             `xml:"vendor,omitempty"`
    IOMMUGroup   *NodeDeviceIOMMUGroup        `xml:"iommuGroup"`
    NUMA         *NodeDeviceNUMA              `xml:"numa"`
    PCIExpress   *NodeDevicePCIExpress        `xml:"pci-express"`
    Capabilities []NodeDevicePCISubCapability `xml:"capability"`
}

type NodeDevicePCIExpress Uses

type NodeDevicePCIExpress struct {
    Links []NodeDevicePCIExpressLink `xml:"link"`
}
type NodeDevicePCIExpressLink struct {
    Validity string  `xml:"validity,attr,omitempty"`
    Speed    float64 `xml:"speed,attr,omitempty"`
    Port     *uint   `xml:"port,attr"`
    Width    *uint   `xml:"width,attr"`
}

type NodeDevicePCIMDevType Uses

type NodeDevicePCIMDevType struct {
    ID                 string `xml:"id,attr"`
    Name               string `xml:"name"`
    DeviceAPI          string `xml:"deviceAPI"`
    AvailableInstances uint   `xml:"availableInstances"`
}

type NodeDevicePCIMDevTypesCapability Uses

type NodeDevicePCIMDevTypesCapability struct {
    Types []NodeDevicePCIMDevType `xml:"type"`
}

type NodeDevicePCIPhysFunctionCapability Uses

type NodeDevicePCIPhysFunctionCapability struct {
    Address NodeDevicePCIAddress `xml:"address,omitempty"`
}

type NodeDevicePCISubCapability Uses

type NodeDevicePCISubCapability struct {
    VirtFunctions *NodeDevicePCIVirtFunctionsCapability
    PhysFunction  *NodeDevicePCIPhysFunctionCapability
    MDevTypes     *NodeDevicePCIMDevTypesCapability
    Bridge        *NodeDevicePCIBridgeCapability
}

func (*NodeDevicePCISubCapability) MarshalXML Uses

func (c *NodeDevicePCISubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDevicePCISubCapability) UnmarshalXML Uses

func (c *NodeDevicePCISubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDevicePCIVirtFunctionsCapability Uses

type NodeDevicePCIVirtFunctionsCapability struct {
    Address  []NodeDevicePCIAddress `xml:"address,omitempty"`
    MaxCount int                    `xml:"maxCount,attr,omitempty"`
}

type NodeDeviceSCSICapability Uses

type NodeDeviceSCSICapability struct {
    Host   int    `xml:"host"`
    Bus    int    `xml:"bus"`
    Target int    `xml:"target"`
    Lun    int    `xml:"lun"`
    Type   string `xml:"type"`
}

type NodeDeviceSCSIFCHostCapability Uses

type NodeDeviceSCSIFCHostCapability struct {
    WWNN      string `xml:"wwnn,omitempty"`
    WWPN      string `xml:"wwpn,omitempty"`
    FabricWWN string `xml:"fabric_wwn,omitempty"`
}

type NodeDeviceSCSIFCRemotePortCapability Uses

type NodeDeviceSCSIFCRemotePortCapability struct {
    RPort string `xml:"rport"`
    WWPN  string `xml:"wwpn"`
}

type NodeDeviceSCSIHostCapability Uses

type NodeDeviceSCSIHostCapability struct {
    Host       uint                              `xml:"host"`
    UniqueID   *uint                             `xml:"unique_id"`
    Capability []NodeDeviceSCSIHostSubCapability `xml:"capability"`
}

type NodeDeviceSCSIHostSubCapability Uses

type NodeDeviceSCSIHostSubCapability struct {
    VPortOps *NodeDeviceSCSIVPortOpsCapability
    FCHost   *NodeDeviceSCSIFCHostCapability
}

func (*NodeDeviceSCSIHostSubCapability) MarshalXML Uses

func (c *NodeDeviceSCSIHostSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSIHostSubCapability) UnmarshalXML Uses

func (c *NodeDeviceSCSIHostSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSITargetCapability Uses

type NodeDeviceSCSITargetCapability struct {
    Target     string                              `xml:"target"`
    Capability []NodeDeviceSCSITargetSubCapability `xml:"capability"`
}

type NodeDeviceSCSITargetSubCapability Uses

type NodeDeviceSCSITargetSubCapability struct {
    FCRemotePort *NodeDeviceSCSIFCRemotePortCapability
}

func (*NodeDeviceSCSITargetSubCapability) MarshalXML Uses

func (c *NodeDeviceSCSITargetSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceSCSITargetSubCapability) UnmarshalXML Uses

func (c *NodeDeviceSCSITargetSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSCSIVPortOpsCapability Uses

type NodeDeviceSCSIVPortOpsCapability struct {
    VPorts    int `xml:"vports,omitempty"`
    MaxVPorts int `xml:"maxvports,omitempty"`
}

type NodeDeviceStorageCapability Uses

type NodeDeviceStorageCapability struct {
    Block        string                           `xml:"block,omitempty"`
    Bus          string                           `xml:"bus,omitempty"`
    DriverType   string                           `xml:"drive_type,omitempty"`
    Model        string                           `xml:"model,omitempty"`
    Vendor       string                           `xml:"vendor,omitempty"`
    Serial       string                           `xml:"serial,omitempty"`
    Size         *uint                            `xml:"size"`
    Capatibility []NodeDeviceStorageSubCapability `xml:"capability"`
}

type NodeDeviceStorageRemovableCapability Uses

type NodeDeviceStorageRemovableCapability struct {
    MediaAvailable *uint  `xml:"media_available"`
    MediaSize      *uint  `xml:"media_size"`
    MediaLabel     string `xml:"media_label,omitempty"`
}

type NodeDeviceStorageSubCapability Uses

type NodeDeviceStorageSubCapability struct {
    Removable *NodeDeviceStorageRemovableCapability
}

func (*NodeDeviceStorageSubCapability) MarshalXML Uses

func (c *NodeDeviceStorageSubCapability) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*NodeDeviceStorageSubCapability) UnmarshalXML Uses

func (c *NodeDeviceStorageSubCapability) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type NodeDeviceSystemCapability Uses

type NodeDeviceSystemCapability struct {
    Product  string                    `xml:"product,omitempty"`
    Hardware *NodeDeviceSystemHardware `xml:"hardware"`
    Firmware *NodeDeviceSystemFirmware `xml:"firmware"`
}

type NodeDeviceSystemFirmware Uses

type NodeDeviceSystemFirmware struct {
    Vendor      string `xml:"vendor"`
    Version     string `xml:"version"`
    ReleaseData string `xml:"release_date"`
}

type NodeDeviceSystemHardware Uses

type NodeDeviceSystemHardware struct {
    Vendor  string `xml:"vendor"`
    Version string `xml:"version"`
    Serial  string `xml:"serial"`
    UUID    string `xml:"uuid"`
}

type NodeDeviceUSBCapability Uses

type NodeDeviceUSBCapability struct {
    Number      int    `xml:"number"`
    Class       int    `xml:"class"`
    Subclass    int    `xml:"subclass"`
    Protocol    int    `xml:"protocol"`
    Description string `xml:"description,omitempty"`
}

type NodeDeviceUSBDeviceCapability Uses

type NodeDeviceUSBDeviceCapability struct {
    Bus     int              `xml:"bus"`
    Device  int              `xml:"device"`
    Product NodeDeviceIDName `xml:"product,omitempty"`
    Vendor  NodeDeviceIDName `xml:"vendor,omitempty"`
}

type Secret Uses

type Secret struct {
    XMLName     xml.Name     `xml:"secret"`
    Ephemeral   string       `xml:"ephemeral,attr,omitempty"`
    Private     string       `xml:"private,attr,omitempty"`
    Description string       `xml:"description,omitempty"`
    UUID        string       `xml:"uuid,omitempty"`
    Usage       *SecretUsage `xml:"usage"`
}

func (*Secret) Marshal Uses

func (s *Secret) Marshal() (string, error)

func (*Secret) Unmarshal Uses

func (s *Secret) Unmarshal(doc string) error

type SecretUsage Uses

type SecretUsage struct {
    Type   string `xml:"type,attr"`
    Volume string `xml:"volume,omitempty"`
    Name   string `xml:"name,omitempty"`
    Target string `xml:"target,omitempty"`
}

type StorageEncryption Uses

type StorageEncryption struct {
    Format string                   `xml:"format,attr"`
    Secret *StorageEncryptionSecret `xml:"secret"`
    Cipher *StorageEncryptionCipher `xml:"cipher"`
    Ivgen  *StorageEncryptionIvgen  `xml:"ivgen"`
}

type StorageEncryptionCipher Uses

type StorageEncryptionCipher struct {
    Name string `xml:"name,attr"`
    Size uint64 `xml:"size,attr"`
    Mode string `xml:"mode,attr"`
    Hash string `xml:"hash,attr"`
}

type StorageEncryptionIvgen Uses

type StorageEncryptionIvgen struct {
    Name string `xml:"name,attr"`
    Hash string `xml:"hash,attr"`
}

type StorageEncryptionSecret Uses

type StorageEncryptionSecret struct {
    Type string `xml:"type,attr"`
    UUID string `xml:"uuid,attr"`
}

type StoragePool Uses

type StoragePool struct {
    XMLName    xml.Name           `xml:"pool"`
    Type       string             `xml:"type,attr"`
    Name       string             `xml:"name,omitempty"`
    UUID       string             `xml:"uuid,omitempty"`
    Allocation *StoragePoolSize   `xml:"allocation"`
    Capacity   *StoragePoolSize   `xml:"capacity"`
    Available  *StoragePoolSize   `xml:"available"`
    Target     *StoragePoolTarget `xml:"target"`
    Source     *StoragePoolSource `xml:"source"`
}

func (*StoragePool) Marshal Uses

func (s *StoragePool) Marshal() (string, error)

func (*StoragePool) Unmarshal Uses

func (s *StoragePool) Unmarshal(doc string) error

type StoragePoolPCIAddress Uses

type StoragePoolPCIAddress struct {
    Domain   *uint `xml:"domain,attr"`
    Bus      *uint `xml:"bus,attr"`
    Slot     *uint `xml:"slot,attr"`
    Function *uint `xml:"function,attr"`
}

func (*StoragePoolPCIAddress) MarshalXML Uses

func (a *StoragePoolPCIAddress) MarshalXML(e *xml.Encoder, start xml.StartElement) error

func (*StoragePoolPCIAddress) UnmarshalXML Uses

func (a *StoragePoolPCIAddress) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type StoragePoolSize Uses

type StoragePoolSize struct {
    Unit  string `xml:"unit,attr,omitempty"`
    Value uint64 `xml:",chardata"`
}

type StoragePoolSource Uses

type StoragePoolSource struct {
    Name      string                      `xml:"name,omitempty"`
    Dir       *StoragePoolSourceDir       `xml:"dir"`
    Host      []StoragePoolSourceHost     `xml:"host"`
    Device    []StoragePoolSourceDevice   `xml:"device"`
    Auth      *StoragePoolSourceAuth      `xml:"auth"`
    Vendor    *StoragePoolSourceVendor    `xml:"vendor"`
    Product   *StoragePoolSourceProduct   `xml:"product"`
    Format    *StoragePoolSourceFormat    `xml:"format"`
    Adapter   *StoragePoolSourceAdapter   `xml:"adapter"`
    Initiator *StoragePoolSourceInitiator `xml:"initiator"`
}

type StoragePoolSourceAdapter Uses

type StoragePoolSourceAdapter struct {
    Type       string                              `xml:"type,attr,omitempty"`
    Name       string                              `xml:"name,attr,omitempty"`
    Parent     string                              `xml:"parent,attr,omitempty"`
    Managed    string                              `xml:"managed,attr,omitempty"`
    WWNN       string                              `xml:"wwnn,attr,omitempty"`
    WWPN       string                              `xml:"wwpn,attr,omitempty"`
    ParentAddr *StoragePoolSourceAdapterParentAddr `xml:"parentaddr"`
}

type StoragePoolSourceAdapterParentAddr Uses

type StoragePoolSourceAdapterParentAddr struct {
    UniqueID uint64                 `xml:"unique_id,attr"`
    Address  *StoragePoolPCIAddress `xml:"address"`
}

type StoragePoolSourceAuth Uses

type StoragePoolSourceAuth struct {
    Type     string                       `xml:"type,attr"`
    Username string                       `xml:"username,attr"`
    Secret   *StoragePoolSourceAuthSecret `xml:"secret"`
}

type StoragePoolSourceAuthSecret Uses

type StoragePoolSourceAuthSecret struct {
    Usage string `xml:"usage,attr,omitempty"`
    UUID  string `xml:"uuid,attr,omitempty"`
}

type StoragePoolSourceDevice Uses

type StoragePoolSourceDevice struct {
    Path          string                              `xml:"path,attr"`
    PartSeparator string                              `xml:"part_separator,attr,omitempty"`
    FreeExtents   []StoragePoolSourceDeviceFreeExtent `xml:"freeExtent"`
}

type StoragePoolSourceDeviceFreeExtent Uses

type StoragePoolSourceDeviceFreeExtent struct {
    Start uint64 `xml:"start,attr"`
    End   uint64 `xml:"end,attr"`
}

type StoragePoolSourceDir Uses

type StoragePoolSourceDir struct {
    Path string `xml:"path,attr"`
}

type StoragePoolSourceFormat Uses

type StoragePoolSourceFormat struct {
    Type string `xml:"type,attr"`
}

type StoragePoolSourceHost Uses

type StoragePoolSourceHost struct {
    Name string `xml:"name,attr"`
    Port string `xml:"port,attr,omitempty"`
}

type StoragePoolSourceInitiator Uses

type StoragePoolSourceInitiator struct {
    IQN StoragePoolSourceInitiatorIQN `xml:"iqn"`
}

type StoragePoolSourceInitiatorIQN Uses

type StoragePoolSourceInitiatorIQN struct {
    Name string `xml:"name,attr,omitempty"`
}

type StoragePoolSourceProduct Uses

type StoragePoolSourceProduct struct {
    Name string `xml:"name,attr"`
}

type StoragePoolSourceVendor Uses

type StoragePoolSourceVendor struct {
    Name string `xml:"name,attr"`
}

type StoragePoolTarget Uses

type StoragePoolTarget struct {
    Path        string                        `xml:"path,omitempty"`
    Permissions *StoragePoolTargetPermissions `xml:"permissions"`
    Timestamps  *StoragePoolTargetTimestamps  `xml:"timestamps"`
    Encryption  *StorageEncryption            `xml:"encryption"`
}

type StoragePoolTargetPermissions Uses

type StoragePoolTargetPermissions struct {
    Owner string `xml:"owner,omitempty"`
    Group string `xml:"group,omitempty"`
    Mode  string `xml:"mode,omitempty"`
    Label string `xml:"label,omitempty"`
}

type StoragePoolTargetTimestamps Uses

type StoragePoolTargetTimestamps struct {
    Atime string `xml:"atime"`
    Mtime string `xml:"mtime"`
    Ctime string `xml:"ctime"`
}

type StorageVolume Uses

type StorageVolume struct {
    XMLName      xml.Name                   `xml:"volume"`
    Type         string                     `xml:"type,attr,omitempty"`
    Name         string                     `xml:"name"`
    Key          string                     `xml:"key,omitempty"`
    Allocation   *StorageVolumeSize         `xml:"allocation"`
    Capacity     *StorageVolumeSize         `xml:"capacity"`
    Physical     *StorageVolumeSize         `xml:"physical"`
    Target       *StorageVolumeTarget       `xml:"target"`
    BackingStore *StorageVolumeBackingStore `xml:"backingStore"`
}

func (*StorageVolume) Marshal Uses

func (s *StorageVolume) Marshal() (string, error)

func (*StorageVolume) Unmarshal Uses

func (s *StorageVolume) Unmarshal(doc string) error

type StorageVolumeBackingStore Uses

type StorageVolumeBackingStore struct {
    Path        string                          `xml:"path"`
    Format      *StorageVolumeTargetFormat      `xml:"format"`
    Permissions *StorageVolumeTargetPermissions `xml:"permissions"`
}

type StorageVolumeSize Uses

type StorageVolumeSize struct {
    Unit  string `xml:"unit,attr,omitempty"`
    Value uint64 `xml:",chardata"`
}

type StorageVolumeTarget Uses

type StorageVolumeTarget struct {
    Path        string                          `xml:"path,omitempty"`
    Format      *StorageVolumeTargetFormat      `xml:"format"`
    Permissions *StorageVolumeTargetPermissions `xml:"permissions"`
    Timestamps  *StorageVolumeTargetTimestamps  `xml:"timestamps"`
    Compat      string                          `xml:"compat,omitempty"`
    NoCOW       *struct{}                       `xml:"nocow"`
    Features    []StorageVolumeTargetFeature    `xml:"features"`
    Encryption  *StorageEncryption              `xml:"encryption"`
}

type StorageVolumeTargetFeature Uses

type StorageVolumeTargetFeature struct {
    LazyRefcounts *struct{} `xml:"lazy_refcounts"`
}

type StorageVolumeTargetFormat Uses

type StorageVolumeTargetFormat struct {
    Type string `xml:"type,attr"`
}

type StorageVolumeTargetPermissions Uses

type StorageVolumeTargetPermissions struct {
    Owner string `xml:"owner,omitempty"`
    Group string `xml:"group,omitempty"`
    Mode  string `xml:"mode,omitempty"`
    Label string `xml:"label,omitempty"`
}

type StorageVolumeTargetTimestamps Uses

type StorageVolumeTargetTimestamps struct {
    Atime string `xml:"atime"`
    Mtime string `xml:"mtime"`
    Ctime string `xml:"ctime"`
}

Package libvirtxml imports 5 packages (graph) and is imported by 5 packages. Updated 2018-01-17. Refresh now. Tools for package owners.