diff options
| author | OpenShift Merge Robot <openshift-merge-robot@users.noreply.github.com> | 2021-03-25 10:50:01 -0700 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-03-25 10:50:01 -0700 |
| commit | db356748738762c31a036c179d23488d7978dabf (patch) | |
| tree | a01d257cba3349b47ff743b11eaa7f496bac991b /vendor | |
| parent | 24581d8760691af1657c4f890d42ebd76f5e85c4 (diff) | |
| parent | 4ab8a6f67eb9de0de40d478cb0cbec05b1b725c0 (diff) | |
| download | podman-db356748738762c31a036c179d23488d7978dabf.tar.gz podman-db356748738762c31a036c179d23488d7978dabf.tar.bz2 podman-db356748738762c31a036c179d23488d7978dabf.zip | |
Merge pull request #9781 from baude/addqemu
introduce podman machine
Diffstat (limited to 'vendor')
82 files changed, 28867 insertions, 0 deletions
diff --git a/vendor/github.com/coreos/stream-metadata-go/LICENSE b/vendor/github.com/coreos/stream-metadata-go/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go new file mode 100644 index 000000000..9ffc7f7d1 --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/fcos.go @@ -0,0 +1,27 @@ +// Package fedoracoreos contains APIs defining well-known +// streams for Fedora CoreOS and a method to retrieve +// the URL for a stream endpoint. +package fedoracoreos + +import ( + "fmt" + "net/url" + + "github.com/coreos/stream-metadata-go/fedoracoreos/internals" +) + +const ( + // StreamStable is the default stream + StreamStable = "stable" + // StreamTesting is what is intended to land in stable + StreamTesting = "testing" + // StreamNext usually tracks the next Fedora major version + StreamNext = "next" +) + +// GetStreamURL returns the URL for the given stream +func GetStreamURL(stream string) url.URL { + u := internals.GetBaseURL() + u.Path = fmt.Sprintf("streams/%s.json", stream) + return u +} diff --git a/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go new file mode 100644 index 000000000..48b6addbc --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/fedoracoreos/internals/fcosinternals.go @@ -0,0 +1,33 @@ +// Package internals contains functions for accessing +// the underlying "releases" and coreos-assembler builds +// backing streams. General user code should avoid +// this package and use streams. +package internals + +import ( + "fmt" + "net/url" +) + +// GetBaseURL returns the base URL +func GetBaseURL() url.URL { + return url.URL{ + Scheme: "https", + Host: "builds.coreos.fedoraproject.org", + } +} + +// GetReleaseIndexURL returns the URL for the release index of a given stream. +// Avoid this unless you have a specific need to test a specific release. +func GetReleaseIndexURL(stream string) url.URL { + u := GetBaseURL() + u.Path = fmt.Sprintf("prod/streams/%s/releases.json", stream) + return u +} + +// GetCosaBuild returns the coreos-assembler build URL +func GetCosaBuild(stream, buildID, arch string) url.URL { + u := GetBaseURL() + u.Path = fmt.Sprintf("prod/streams/%s/builds/%s/%s/", stream, buildID, arch) + return u +} diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go b/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go new file mode 100644 index 000000000..320d84b41 --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/stream/rhcos/rhcos.go @@ -0,0 +1,18 @@ +package rhcos + +// Extensions is data specific to Red Hat Enterprise Linux CoreOS +type Extensions struct { + AzureDisk *AzureDisk `json:"azure-disk,omitempty"` +} + +// AzureDisk represents an Azure disk image that can be imported +// into an image gallery or otherwise replicated, and then used +// as a boot source for virtual machines. +type AzureDisk struct { + // Release is the source release version + Release string `json:"release"` + // URL to an image already stored in Azure infrastructure + // that can be copied into an image gallery. Avoid creating VMs directly + // from this URL as that may lead to performance limitations. + URL string `json:"url,omitempty"` +} diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/stream.go b/vendor/github.com/coreos/stream-metadata-go/stream/stream.go new file mode 100644 index 000000000..e3f100cea --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/stream/stream.go @@ -0,0 +1,74 @@ +// Package stream models a CoreOS "stream", which is +// a description of the recommended set of binary images for CoreOS. Use +// this API to find cloud images, bare metal disk images, etc. +package stream + +import ( + "github.com/coreos/stream-metadata-go/stream/rhcos" +) + +// Stream contains artifacts available in a stream +type Stream struct { + Stream string `json:"stream"` + Metadata Metadata `json:"metadata"` + Architectures map[string]Arch `json:"architectures"` +} + +// Metadata for a release or stream +type Metadata struct { + LastModified string `json:"last-modified"` +} + +// Arch contains release details for a particular hardware architecture +type Arch struct { + Artifacts map[string]PlatformArtifacts `json:"artifacts"` + Images Images `json:"images,omitempty"` + // RHELCoreOSExtensions is data specific to Red Hat Enterprise Linux CoreOS + RHELCoreOSExtensions *rhcos.Extensions `json:"rhel-coreos-extensions,omitempty"` +} + +// PlatformArtifacts contains images for a platform +type PlatformArtifacts struct { + Release string `json:"release"` + Formats map[string]ImageFormat `json:"formats"` +} + +// ImageFormat contains all artifacts for a single OS image +type ImageFormat struct { + Disk *Artifact `json:"disk,omitempty"` + Kernel *Artifact `json:"kernel,omitempty"` + Initramfs *Artifact `json:"initramfs,omitempty"` + Rootfs *Artifact `json:"rootfs,omitempty"` +} + +// Artifact represents one image file, plus its metadata +type Artifact struct { + Location string `json:"location"` + Signature string `json:"signature"` + Sha256 string `json:"sha256"` + UncompressedSha256 string `json:"uncompressed-sha256,omitempty"` +} + +// Images contains images available in cloud providers +type Images struct { + Aws *AwsImage `json:"aws,omitempty"` + Gcp *GcpImage `json:"gcp,omitempty"` +} + +// AwsImage represents an image across all AWS regions +type AwsImage struct { + Regions map[string]AwsRegionImage `json:"regions,omitempty"` +} + +// AwsRegionImage represents an image in one AWS region +type AwsRegionImage struct { + Release string `json:"release"` + Image string `json:"image"` +} + +// GcpImage represents a GCP cloud image +type GcpImage struct { + Project string `json:"project,omitempty"` + Family string `json:"family,omitempty"` + Name string `json:"name,omitempty"` +} diff --git a/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go b/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go new file mode 100644 index 000000000..ffd779c58 --- /dev/null +++ b/vendor/github.com/coreos/stream-metadata-go/stream/stream_utils.go @@ -0,0 +1,47 @@ +package stream + +import "fmt" + +// FormatPrefix describes a stream+architecture combination, intended for prepending to error messages +func (st *Stream) FormatPrefix(archname string) string { + return fmt.Sprintf("%s/%s", st.Stream, archname) +} + +// GetArchitecture loads the architecture-specific builds from a stream, +// with a useful descriptive error message if the architecture is not found. +func (st *Stream) GetArchitecture(archname string) (*Arch, error) { + archdata, ok := st.Architectures[archname] + if !ok { + return nil, fmt.Errorf("stream:%s does not have architecture '%s'", st.Stream, archname) + } + return &archdata, nil +} + +// GetAwsRegionImage returns the release data (AMI and release ID) for a particular +// architecture and region. +func (st *Stream) GetAwsRegionImage(archname, region string) (*AwsRegionImage, error) { + starch, err := st.GetArchitecture(archname) + if err != nil { + return nil, err + } + awsimages := starch.Images.Aws + if awsimages == nil { + return nil, fmt.Errorf("%s: No AWS images", st.FormatPrefix(archname)) + } + var regionVal AwsRegionImage + var ok bool + if regionVal, ok = awsimages.Regions[region]; !ok { + return nil, fmt.Errorf("%s: No AWS images in region %s", st.FormatPrefix(archname), region) + } + + return ®ionVal, nil +} + +// GetAMI returns the AWS machine image for a particular architecture and region. +func (st *Stream) GetAMI(archname, region string) (string, error) { + regionVal, err := st.GetAwsRegionImage(archname, region) + if err != nil { + return "", err + } + return regionVal.Image, nil +} diff --git a/vendor/github.com/digitalocean/go-libvirt/.travis.yml b/vendor/github.com/digitalocean/go-libvirt/.travis.yml new file mode 100644 index 000000000..5852afcfd --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/.travis.yml @@ -0,0 +1,62 @@ +language: go +os: linux +dist: bionic +sudo: require + +cache: + directories: + - $HOME/.ccache + +go: + - "1.15" + +env: + global: + - CCACHE_TEMPDIR=/tmp/.ccache-temp + matrix: + - LIBVIRT=2.3.0 EXT=xz + - LIBVIRT=3.1.0 EXT=xz + - LIBVIRT=5.1.0 EXT=xz + +before_install: + - go get golang.org/x/lint/golint + - go get golang.org/x/tools/cmd/goyacc + +install: + # credit here goes to the go-libvirt authors, + # see: https://github.com/rgbkrk/libvirt-go/blob/master/.travis.yml + - sudo apt-get -qqy build-dep libvirt + - sudo apt-get -qqy install curl qemu-system-x86 + - sudo mkdir -p /usr/src && sudo chown $(id -u) /usr/src + - curl -O -s https://libvirt.org/sources/libvirt-${LIBVIRT}.tar.${EXT} + - tar -C /usr/src -xf libvirt-${LIBVIRT}.tar.${EXT} + - pushd /usr/src/libvirt-${LIBVIRT} + - ccache --show-stats + - | + env PATH=/usr/lib/ccache:$PATH \ + ./configure --prefix=/usr --localstatedir=/var --sysconfdir=/etc \ + --without-polkit \ + --without-esx --without-vbox --without-xen --without-libxl --without-lxc \ + --with-qemu + - make + - sudo make install + - ccache --show-stats + - popd + - sudo libvirtd -d -l -f libvirtd.conf + - sudo virtlogd -d || true + +before_script: + - go get -d ./... + - sudo qemu-img create -f raw -o size=10M /var/lib/libvirt/images/test.raw + - sudo virsh define .travis/test-domain.xml + - sudo virsh start test + - sudo virsh pool-create .travis/test-pool.xml + - sudo virsh secret-define .travis/test-secret.xml + +script: + - ./scripts/licensecheck.sh + - LIBVIRT_SOURCE=/usr/src/libvirt-${LIBVIRT} go generate ./... + - go build ./... + - golint -set_exit_status ./... + - go vet ./... + - go test -v -tags=integration ./... diff --git a/vendor/github.com/digitalocean/go-libvirt/AUTHORS b/vendor/github.com/digitalocean/go-libvirt/AUTHORS new file mode 100644 index 000000000..e004ab7a1 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/AUTHORS @@ -0,0 +1,24 @@ +Maintainer +---------- +DigitalOcean, Inc + +Original Authors +---------------- +Ben LeMasurier <blemasurier@digitalocean.com> +Matt Layher <mlayher@digitalocean.com> + +Contributors +------------ +Justin Kim <justin@digitalocean.com> +Ricky Medina <rm@do.co> +Charlie Drage <charlie@charliedrage.com> +Michael Koppmann <me@mkoppmann.at> +Simarpreet Singh <simar@linux.com> +Alexander Polyakov <apolyakov@beget.com> +Amanda Andrade <amanda.andrade@serpro.gov.br> +Geoff Hickey <ghickey@digitalocean.com> +Yuriy Taraday <yorik.sar@gmail.com> +Sylvain Baubeau <sbaubeau@redhat.com> +David Schneider <dsbrng25b@gmail.com> +Alec Hothan <ahothan@gmail.com> +Akos Varga <vrgakos@gmail.com>
\ No newline at end of file diff --git a/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md b/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md new file mode 100644 index 000000000..1b5b74106 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/CONTRIBUTING.md @@ -0,0 +1,30 @@ +Contributing +============ + +The `go-libvirt` project makes use of the [GitHub Flow](https://guides.github.com/introduction/flow/) +for contributions. + +If you'd like to contribute to the project, please +[open an issue](https://github.com/digitalocean/go-libvirt/issues/new) or find an +[existing issue](https://github.com/digitalocean/go-libvirt/issues) that you'd like +to take on. This ensures that efforts are not duplicated, and that a new feature +aligns with the focus of the rest of the repository. + +Once your suggestion has been submitted and discussed, please be sure that your +code meets the following criteria: + - code is completely `gofmt`'d + - new features or codepaths have appropriate test coverage + - `go test ./...` passes + - `go vet ./...` passes + - `golint ./...` returns no warnings, including documentation comment warnings + +In addition, if this is your first time contributing to the `go-libvirt` project, +add your name and email address to the +[AUTHORS](https://github.com/digitalocean/go-libvirt/blob/master/AUTHORS) file +under the "Contributors" section using the format: +`First Last <email@example.com>`. + +Finally, submit a pull request for review! + +Questions? Feel free to join us in [`#go-qemu` on freenode](https://webchat.freenode.net/) +if you'd like to discuss the project. diff --git a/vendor/github.com/digitalocean/go-libvirt/LICENSE.md b/vendor/github.com/digitalocean/go-libvirt/LICENSE.md new file mode 100644 index 000000000..f5f4b8b5e --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/LICENSE.md @@ -0,0 +1,195 @@ +Apache License +============== + +_Version 2.0, January 2004_ +_<<http://www.apache.org/licenses/>>_ + +### Terms and Conditions for use, reproduction, and distribution + +#### 1. Definitions + +“License” shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +“Licensor” shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +“Legal Entity” shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, “control” means **(i)** the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the +outstanding shares, or **(iii)** beneficial ownership of such entity. + +“You” (or “Your”) shall mean an individual or Legal Entity exercising +permissions granted by this License. + +“Source” form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +“Object” form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +“Work” shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +“Derivative Works” shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +“Contribution” shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +“submitted” means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as “Not a Contribution.” + +“Contributor” shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +#### 2. Grant of Copyright License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +#### 3. Grant of Patent License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +#### 4. Redistribution + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +* **(a)** You must give any other recipients of the Work or Derivative Works a copy of +this License; and +* **(b)** You must cause any modified files to carry prominent notices stating that You +changed the files; and +* **(c)** You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +#### 5. Submission of Contributions + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +#### 6. Trademarks + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +#### 7. Disclaimer of Warranty + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +#### 8. Limitation of Liability + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +#### 9. Accepting Warranty or Additional Liability + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +_END OF TERMS AND CONDITIONS_ + +### APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets `[]` replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same “printed page” as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/vendor/github.com/digitalocean/go-libvirt/README.md b/vendor/github.com/digitalocean/go-libvirt/README.md new file mode 100644 index 000000000..125262612 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/README.md @@ -0,0 +1,171 @@ +libvirt [](http://godoc.org/github.com/digitalocean/go-libvirt) [](https://travis-ci.org/digitalocean/go-libvirt) [](https://goreportcard.com/report/github.com/digitalocean/go-libvirt) +==== + +Package `go-libvirt` provides a pure Go interface for interacting with libvirt. + +Rather than using libvirt's C bindings, this package makes use of +libvirt's RPC interface, as documented [here](https://libvirt.org/internals/rpc.html). +Connections to the libvirt server may be local, or remote. RPC packets are encoded +using the XDR standard as defined by [RFC 4506](https://tools.ietf.org/html/rfc4506.html). + +libvirt's RPC interface is quite extensive, and changes from one version to the +next, so this project uses a pair of code generators to build the go bindings. +The code generators should be run whenever you want to build go-libvirt for a +new version of libvirt. See the next section for directions on re-generating +go-libvirt. + +[Pull requests are welcome](https://github.com/digitalocean/go-libvirt/blob/master/CONTRIBUTING.md)! + +Running the Code Generators +--------------------------- + +The code generator doesn't run automatically when you build go-libvirt. It's +meant to be run manually any time you change the version of libvirt you're +using. When you download go-libvirt it will come with generated files +corresponding to a particular version of libvirt. You can use the library as-is, +but the generated code may be missing libvirt functions, if you're using a newer +version of libvirt, or it may have extra functions that will return +'unimplemented' errors if you try to call them. If this is a problem, you should +re-run the code generator. To do this, follow these steps: + +- First, download a copy of the libvirt sources corresponding to the version you + want to use. +- Next, run `autogen.sh` in the libvirt directory. The autotools will check for + necessary libraries and prepare libvirt for building. We don't actually need + to build libvirt, but we do require some header files that are produced in + this step. +- Finally, set the environment variable `LIBVIRT_SOURCE` to the directory you + put libvirt into, and run `go generate ./...` from the go-libvirt directory. + This runs both of the go-libvirt's code generators. + +How to Use This Library +----------------------- + +Once you've vendored go-libvirt into your project, you'll probably want to call +some libvirt functions. There's some example code below showing how to connect +to libvirt and make one such call, but once you get past the introduction you'll +next want to call some other libvirt functions. How do you find them? + +Start with the [libvirt API reference](https://libvirt.org/html/index.html). +Let's say you want to gracefully shutdown a VM, and after reading through the +libvirt docs you determine that virDomainShutdown() is the function you want to +call to do that. Where's that function in go-libvirt? We transform the names +slightly when building the go bindings. There's no need for a global prefix like +"vir" in Go, since all our functions are inside the package namespace, so we +drop it. That means the Go function for `virDomainShutdown()` is just `DomainShutdown()`, +and sure enough, you can find the Go function `DomainShutdown()` in libvirt.gen.go, +with parameters and return values equivalent to those documented in the API +reference. + +Suppose you then decide you need more control over your shutdown, so you switch +over to `virDomainShutdownFlags()`. As its name suggests, this function takes a +flag parameter which has possible values specified in an enum called +`virDomainShutdownFlagValues`. Flag types like this are a little tricky for the +code generator, because the C functions just take an integer type - only the +libvirt documentation actually ties the flags to the enum types. In most cases +though we're able to generate a wrapper function with a distinct flag type, +making it easier for Go tooling to suggest possible flag values while you're +working. Checking the documentation for this function: + +`godoc github.com/digitalocean/go-libvirt DomainShutdownFlags` + +returns this: + +`func (l *Libvirt) DomainShutdownFlags(Dom Domain, Flags DomainShutdownFlagValues) (err error)` + +If you want to see the possible flag values, `godoc` can help again: + +``` +$ godoc github.com/digitalocean/go-libvirt DomainShutdownFlagValues + +type DomainShutdownFlagValues int32 + DomainShutdownFlagValues as declared in libvirt/libvirt-domain.h:1121 + +const ( + DomainShutdownDefault DomainShutdownFlagValues = iota + DomainShutdownAcpiPowerBtn DomainShutdownFlagValues = 1 + DomainShutdownGuestAgent DomainShutdownFlagValues = 2 + DomainShutdownInitctl DomainShutdownFlagValues = 4 + DomainShutdownSignal DomainShutdownFlagValues = 8 + DomainShutdownParavirt DomainShutdownFlagValues = 16 +) + DomainShutdownFlagValues enumeration from libvirt/libvirt-domain.h:1121 +``` + +One other suggestion: most of the code in go-libvirt is now generated, but a few +hand-written routines still exist in libvirt.go, and wrap calls to the generated +code with slightly different parameters or return values. We suggest avoiding +these hand-written routines and calling the generated routines in libvirt.gen.go +instead. Over time these handwritten routines will be removed from go-libvirt. + +Warning +------- + +While these package are reasonably well-tested and have seen some use inside of +DigitalOcean, there may be subtle bugs which could cause the packages to act +in unexpected ways. Use at your own risk! + +In addition, the API is not considered stable at this time. If you would like +to include package `libvirt` in a project, we highly recommend vendoring it into +your project. + +Example +------- + +```go +package main + +import ( + "fmt" + "log" + "net" + "time" + + "github.com/digitalocean/go-libvirt" +) + +func main() { + // This dials libvirt on the local machine, but you can substitute the first + // two parameters with "tcp", "<ip address>:<port>" to connect to libvirt on + // a remote machine. + c, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second) + if err != nil { + log.Fatalf("failed to dial libvirt: %v", err) + } + + l := libvirt.New(c) + if err := l.Connect(); err != nil { + log.Fatalf("failed to connect: %v", err) + } + + v, err := l.Version() + if err != nil { + log.Fatalf("failed to retrieve libvirt version: %v", err) + } + fmt.Println("Version:", v) + + domains, err := l.Domains() + if err != nil { + log.Fatalf("failed to retrieve domains: %v", err) + } + + fmt.Println("ID\tName\t\tUUID") + fmt.Printf("--------------------------------------------------------\n") + for _, d := range domains { + fmt.Printf("%d\t%s\t%x\n", d.ID, d.Name, d.UUID) + } + + if err := l.Disconnect(); err != nil { + log.Fatalf("failed to disconnect: %v", err) + } +} + +``` + +``` +Version: 1.3.4 +ID Name UUID +-------------------------------------------------------- +1 Test-1 dc329f87d4de47198cfd2e21c6105b01 +2 Test-2 dc229f87d4de47198cfd2e21c6105b01 +``` diff --git a/vendor/github.com/digitalocean/go-libvirt/const.gen.go b/vendor/github.com/digitalocean/go-libvirt/const.gen.go new file mode 100644 index 000000000..6e581d22c --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/const.gen.go @@ -0,0 +1,2414 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// WARNING: This file has automatically been generated +// Code generated by https://git.io/c-for-go. DO NOT EDIT. + +package libvirt + +const ( + // ExportVar as defined in libvirt/libvirt-common.h:57 + ExportVar = 0 + // TypedParamFieldLength as defined in libvirt/libvirt-common.h:170 + TypedParamFieldLength = 80 + // SecurityLabelBuflen as defined in libvirt/libvirt-host.h:84 + SecurityLabelBuflen = 4097 + // SecurityModelBuflen as defined in libvirt/libvirt-host.h:112 + SecurityModelBuflen = 257 + // SecurityDoiBuflen as defined in libvirt/libvirt-host.h:119 + SecurityDoiBuflen = 257 + // NodeCPUStatsFieldLength as defined in libvirt/libvirt-host.h:180 + NodeCPUStatsFieldLength = 80 + // NodeCPUStatsKernel as defined in libvirt/libvirt-host.h:197 + NodeCPUStatsKernel = "kernel" + // NodeCPUStatsUser as defined in libvirt/libvirt-host.h:205 + NodeCPUStatsUser = "user" + // NodeCPUStatsIdle as defined in libvirt/libvirt-host.h:213 + NodeCPUStatsIdle = "idle" + // NodeCPUStatsIowait as defined in libvirt/libvirt-host.h:221 + NodeCPUStatsIowait = "iowait" + // NodeCPUStatsIntr as defined in libvirt/libvirt-host.h:229 + NodeCPUStatsIntr = "intr" + // NodeCPUStatsUtilization as defined in libvirt/libvirt-host.h:238 + NodeCPUStatsUtilization = "utilization" + // NodeMemoryStatsFieldLength as defined in libvirt/libvirt-host.h:258 + NodeMemoryStatsFieldLength = 80 + // NodeMemoryStatsTotal as defined in libvirt/libvirt-host.h:275 + NodeMemoryStatsTotal = "total" + // NodeMemoryStatsFree as defined in libvirt/libvirt-host.h:284 + NodeMemoryStatsFree = "free" + // NodeMemoryStatsBuffers as defined in libvirt/libvirt-host.h:292 + NodeMemoryStatsBuffers = "buffers" + // NodeMemoryStatsCached as defined in libvirt/libvirt-host.h:300 + NodeMemoryStatsCached = "cached" + // NodeMemorySharedPagesToScan as defined in libvirt/libvirt-host.h:321 + NodeMemorySharedPagesToScan = "shm_pages_to_scan" + // NodeMemorySharedSleepMillisecs as defined in libvirt/libvirt-host.h:329 + NodeMemorySharedSleepMillisecs = "shm_sleep_millisecs" + // NodeMemorySharedPagesShared as defined in libvirt/libvirt-host.h:337 + NodeMemorySharedPagesShared = "shm_pages_shared" + // NodeMemorySharedPagesSharing as defined in libvirt/libvirt-host.h:345 + NodeMemorySharedPagesSharing = "shm_pages_sharing" + // NodeMemorySharedPagesUnshared as defined in libvirt/libvirt-host.h:353 + NodeMemorySharedPagesUnshared = "shm_pages_unshared" + // NodeMemorySharedPagesVolatile as defined in libvirt/libvirt-host.h:361 + NodeMemorySharedPagesVolatile = "shm_pages_volatile" + // NodeMemorySharedFullScans as defined in libvirt/libvirt-host.h:369 + NodeMemorySharedFullScans = "shm_full_scans" + // NodeMemorySharedMergeAcrossNodes as defined in libvirt/libvirt-host.h:381 + NodeMemorySharedMergeAcrossNodes = "shm_merge_across_nodes" + // NodeSevPdh as defined in libvirt/libvirt-host.h:449 + NodeSevPdh = "pdh" + // NodeSevCertChain as defined in libvirt/libvirt-host.h:458 + NodeSevCertChain = "cert-chain" + // NodeSevCbitpos as defined in libvirt/libvirt-host.h:465 + NodeSevCbitpos = "cbitpos" + // NodeSevReducedPhysBits as defined in libvirt/libvirt-host.h:473 + NodeSevReducedPhysBits = "reduced-phys-bits" + // UUIDBuflen as defined in libvirt/libvirt-host.h:558 + UUIDBuflen = 16 + // UUIDStringBuflen as defined in libvirt/libvirt-host.h:567 + UUIDStringBuflen = 37 + // ConnectIdentityUserName as defined in libvirt/libvirt-host.h:592 + ConnectIdentityUserName = "user-name" + // ConnectIdentityUnixUserID as defined in libvirt/libvirt-host.h:599 + ConnectIdentityUnixUserID = "unix-user-id" + // ConnectIdentityGroupName as defined in libvirt/libvirt-host.h:606 + ConnectIdentityGroupName = "group-name" + // ConnectIdentityUnixGroupID as defined in libvirt/libvirt-host.h:613 + ConnectIdentityUnixGroupID = "unix-group-id" + // ConnectIdentityProcessID as defined in libvirt/libvirt-host.h:620 + ConnectIdentityProcessID = "process-id" + // ConnectIdentityProcessTime as defined in libvirt/libvirt-host.h:631 + ConnectIdentityProcessTime = "process-time" + // ConnectIdentitySaslUserName as defined in libvirt/libvirt-host.h:638 + ConnectIdentitySaslUserName = "sasl-user-name" + // ConnectIdentityX509DistinguishedName as defined in libvirt/libvirt-host.h:645 + ConnectIdentityX509DistinguishedName = "x509-distinguished-name" + // ConnectIdentitySelinuxContext as defined in libvirt/libvirt-host.h:652 + ConnectIdentitySelinuxContext = "selinux-context" + // DomainSchedulerCPUShares as defined in libvirt/libvirt-domain.h:316 + DomainSchedulerCPUShares = "cpu_shares" + // DomainSchedulerGlobalPeriod as defined in libvirt/libvirt-domain.h:324 + DomainSchedulerGlobalPeriod = "global_period" + // DomainSchedulerGlobalQuota as defined in libvirt/libvirt-domain.h:332 + DomainSchedulerGlobalQuota = "global_quota" + // DomainSchedulerVCPUPeriod as defined in libvirt/libvirt-domain.h:340 + DomainSchedulerVCPUPeriod = "vcpu_period" + // DomainSchedulerVCPUQuota as defined in libvirt/libvirt-domain.h:348 + DomainSchedulerVCPUQuota = "vcpu_quota" + // DomainSchedulerEmulatorPeriod as defined in libvirt/libvirt-domain.h:357 + DomainSchedulerEmulatorPeriod = "emulator_period" + // DomainSchedulerEmulatorQuota as defined in libvirt/libvirt-domain.h:366 + DomainSchedulerEmulatorQuota = "emulator_quota" + // DomainSchedulerIothreadPeriod as defined in libvirt/libvirt-domain.h:374 + DomainSchedulerIothreadPeriod = "iothread_period" + // DomainSchedulerIothreadQuota as defined in libvirt/libvirt-domain.h:382 + DomainSchedulerIothreadQuota = "iothread_quota" + // DomainSchedulerWeight as defined in libvirt/libvirt-domain.h:390 + DomainSchedulerWeight = "weight" + // DomainSchedulerCap as defined in libvirt/libvirt-domain.h:398 + DomainSchedulerCap = "cap" + // DomainSchedulerReservation as defined in libvirt/libvirt-domain.h:406 + DomainSchedulerReservation = "reservation" + // DomainSchedulerLimit as defined in libvirt/libvirt-domain.h:414 + DomainSchedulerLimit = "limit" + // DomainSchedulerShares as defined in libvirt/libvirt-domain.h:422 + DomainSchedulerShares = "shares" + // DomainBlockStatsFieldLength as defined in libvirt/libvirt-domain.h:480 + DomainBlockStatsFieldLength = 80 + // DomainBlockStatsReadBytes as defined in libvirt/libvirt-domain.h:488 + DomainBlockStatsReadBytes = "rd_bytes" + // DomainBlockStatsReadReq as defined in libvirt/libvirt-domain.h:496 + DomainBlockStatsReadReq = "rd_operations" + // DomainBlockStatsReadTotalTimes as defined in libvirt/libvirt-domain.h:504 + DomainBlockStatsReadTotalTimes = "rd_total_times" + // DomainBlockStatsWriteBytes as defined in libvirt/libvirt-domain.h:512 + DomainBlockStatsWriteBytes = "wr_bytes" + // DomainBlockStatsWriteReq as defined in libvirt/libvirt-domain.h:520 + DomainBlockStatsWriteReq = "wr_operations" + // DomainBlockStatsWriteTotalTimes as defined in libvirt/libvirt-domain.h:528 + DomainBlockStatsWriteTotalTimes = "wr_total_times" + // DomainBlockStatsFlushReq as defined in libvirt/libvirt-domain.h:536 + DomainBlockStatsFlushReq = "flush_operations" + // DomainBlockStatsFlushTotalTimes as defined in libvirt/libvirt-domain.h:544 + DomainBlockStatsFlushTotalTimes = "flush_total_times" + // DomainBlockStatsErrs as defined in libvirt/libvirt-domain.h:551 + DomainBlockStatsErrs = "errs" + // MigrateParamURI as defined in libvirt/libvirt-domain.h:868 + MigrateParamURI = "migrate_uri" + // MigrateParamDestName as defined in libvirt/libvirt-domain.h:878 + MigrateParamDestName = "destination_name" + // MigrateParamDestXML as defined in libvirt/libvirt-domain.h:897 + MigrateParamDestXML = "destination_xml" + // MigrateParamPersistXML as defined in libvirt/libvirt-domain.h:912 + MigrateParamPersistXML = "persistent_xml" + // MigrateParamBandwidth as defined in libvirt/libvirt-domain.h:922 + MigrateParamBandwidth = "bandwidth" + // MigrateParamBandwidthPostcopy as defined in libvirt/libvirt-domain.h:931 + MigrateParamBandwidthPostcopy = "bandwidth.postcopy" + // MigrateParamGraphicsURI as defined in libvirt/libvirt-domain.h:952 + MigrateParamGraphicsURI = "graphics_uri" + // MigrateParamListenAddress as defined in libvirt/libvirt-domain.h:963 + MigrateParamListenAddress = "listen_address" + // MigrateParamMigrateDisks as defined in libvirt/libvirt-domain.h:972 + MigrateParamMigrateDisks = "migrate_disks" + // MigrateParamDisksPort as defined in libvirt/libvirt-domain.h:982 + MigrateParamDisksPort = "disks_port" + // MigrateParamCompression as defined in libvirt/libvirt-domain.h:992 + MigrateParamCompression = "compression" + // MigrateParamCompressionMtLevel as defined in libvirt/libvirt-domain.h:1001 + MigrateParamCompressionMtLevel = "compression.mt.level" + // MigrateParamCompressionMtThreads as defined in libvirt/libvirt-domain.h:1009 + MigrateParamCompressionMtThreads = "compression.mt.threads" + // MigrateParamCompressionMtDthreads as defined in libvirt/libvirt-domain.h:1017 + MigrateParamCompressionMtDthreads = "compression.mt.dthreads" + // MigrateParamCompressionXbzrleCache as defined in libvirt/libvirt-domain.h:1025 + MigrateParamCompressionXbzrleCache = "compression.xbzrle.cache" + // MigrateParamAutoConvergeInitial as defined in libvirt/libvirt-domain.h:1034 + MigrateParamAutoConvergeInitial = "auto_converge.initial" + // MigrateParamAutoConvergeIncrement as defined in libvirt/libvirt-domain.h:1044 + MigrateParamAutoConvergeIncrement = "auto_converge.increment" + // MigrateParamParallelConnections as defined in libvirt/libvirt-domain.h:1052 + MigrateParamParallelConnections = "parallel.connections" + // MigrateParamTLSDestination as defined in libvirt/libvirt-domain.h:1066 + MigrateParamTLSDestination = "tls.destination" + // DomainCPUStatsCputime as defined in libvirt/libvirt-domain.h:1326 + DomainCPUStatsCputime = "cpu_time" + // DomainCPUStatsUsertime as defined in libvirt/libvirt-domain.h:1332 + DomainCPUStatsUsertime = "user_time" + // DomainCPUStatsSystemtime as defined in libvirt/libvirt-domain.h:1338 + DomainCPUStatsSystemtime = "system_time" + // DomainCPUStatsVcputime as defined in libvirt/libvirt-domain.h:1345 + DomainCPUStatsVcputime = "vcpu_time" + // DomainBlkioWeight as defined in libvirt/libvirt-domain.h:1374 + DomainBlkioWeight = "weight" + // DomainBlkioDeviceWeight as defined in libvirt/libvirt-domain.h:1384 + DomainBlkioDeviceWeight = "device_weight" + // DomainBlkioDeviceReadIops as defined in libvirt/libvirt-domain.h:1395 + DomainBlkioDeviceReadIops = "device_read_iops_sec" + // DomainBlkioDeviceWriteIops as defined in libvirt/libvirt-domain.h:1406 + DomainBlkioDeviceWriteIops = "device_write_iops_sec" + // DomainBlkioDeviceReadBps as defined in libvirt/libvirt-domain.h:1417 + DomainBlkioDeviceReadBps = "device_read_bytes_sec" + // DomainBlkioDeviceWriteBps as defined in libvirt/libvirt-domain.h:1428 + DomainBlkioDeviceWriteBps = "device_write_bytes_sec" + // DomainMemoryParamUnlimited as defined in libvirt/libvirt-domain.h:1447 + DomainMemoryParamUnlimited = 9007199254740991 + // DomainMemoryHardLimit as defined in libvirt/libvirt-domain.h:1456 + DomainMemoryHardLimit = "hard_limit" + // DomainMemorySoftLimit as defined in libvirt/libvirt-domain.h:1465 + DomainMemorySoftLimit = "soft_limit" + // DomainMemoryMinGuarantee as defined in libvirt/libvirt-domain.h:1474 + DomainMemoryMinGuarantee = "min_guarantee" + // DomainMemorySwapHardLimit as defined in libvirt/libvirt-domain.h:1484 + DomainMemorySwapHardLimit = "swap_hard_limit" + // DomainNumaNodeset as defined in libvirt/libvirt-domain.h:1529 + DomainNumaNodeset = "numa_nodeset" + // DomainNumaMode as defined in libvirt/libvirt-domain.h:1537 + DomainNumaMode = "numa_mode" + // DomainBandwidthInAverage as defined in libvirt/libvirt-domain.h:1653 + DomainBandwidthInAverage = "inbound.average" + // DomainBandwidthInPeak as defined in libvirt/libvirt-domain.h:1660 + DomainBandwidthInPeak = "inbound.peak" + // DomainBandwidthInBurst as defined in libvirt/libvirt-domain.h:1667 + DomainBandwidthInBurst = "inbound.burst" + // DomainBandwidthInFloor as defined in libvirt/libvirt-domain.h:1674 + DomainBandwidthInFloor = "inbound.floor" + // DomainBandwidthOutAverage as defined in libvirt/libvirt-domain.h:1681 + DomainBandwidthOutAverage = "outbound.average" + // DomainBandwidthOutPeak as defined in libvirt/libvirt-domain.h:1688 + DomainBandwidthOutPeak = "outbound.peak" + // DomainBandwidthOutBurst as defined in libvirt/libvirt-domain.h:1695 + DomainBandwidthOutBurst = "outbound.burst" + // DomainIothreadPollMaxNs as defined in libvirt/libvirt-domain.h:1995 + DomainIothreadPollMaxNs = "poll_max_ns" + // DomainIothreadPollGrow as defined in libvirt/libvirt-domain.h:2005 + DomainIothreadPollGrow = "poll_grow" + // DomainIothreadPollShrink as defined in libvirt/libvirt-domain.h:2016 + DomainIothreadPollShrink = "poll_shrink" + // PerfParamCmt as defined in libvirt/libvirt-domain.h:2208 + PerfParamCmt = "cmt" + // PerfParamMbmt as defined in libvirt/libvirt-domain.h:2219 + PerfParamMbmt = "mbmt" + // PerfParamMbml as defined in libvirt/libvirt-domain.h:2229 + PerfParamMbml = "mbml" + // PerfParamCacheMisses as defined in libvirt/libvirt-domain.h:2239 + PerfParamCacheMisses = "cache_misses" + // PerfParamCacheReferences as defined in libvirt/libvirt-domain.h:2249 + PerfParamCacheReferences = "cache_references" + // PerfParamInstructions as defined in libvirt/libvirt-domain.h:2259 + PerfParamInstructions = "instructions" + // PerfParamCPUCycles as defined in libvirt/libvirt-domain.h:2269 + PerfParamCPUCycles = "cpu_cycles" + // PerfParamBranchInstructions as defined in libvirt/libvirt-domain.h:2279 + PerfParamBranchInstructions = "branch_instructions" + // PerfParamBranchMisses as defined in libvirt/libvirt-domain.h:2289 + PerfParamBranchMisses = "branch_misses" + // PerfParamBusCycles as defined in libvirt/libvirt-domain.h:2299 + PerfParamBusCycles = "bus_cycles" + // PerfParamStalledCyclesFrontend as defined in libvirt/libvirt-domain.h:2310 + PerfParamStalledCyclesFrontend = "stalled_cycles_frontend" + // PerfParamStalledCyclesBackend as defined in libvirt/libvirt-domain.h:2321 + PerfParamStalledCyclesBackend = "stalled_cycles_backend" + // PerfParamRefCPUCycles as defined in libvirt/libvirt-domain.h:2332 + PerfParamRefCPUCycles = "ref_cpu_cycles" + // PerfParamCPUClock as defined in libvirt/libvirt-domain.h:2343 + PerfParamCPUClock = "cpu_clock" + // PerfParamTaskClock as defined in libvirt/libvirt-domain.h:2354 + PerfParamTaskClock = "task_clock" + // PerfParamPageFaults as defined in libvirt/libvirt-domain.h:2364 + PerfParamPageFaults = "page_faults" + // PerfParamContextSwitches as defined in libvirt/libvirt-domain.h:2374 + PerfParamContextSwitches = "context_switches" + // PerfParamCPUMigrations as defined in libvirt/libvirt-domain.h:2384 + PerfParamCPUMigrations = "cpu_migrations" + // PerfParamPageFaultsMin as defined in libvirt/libvirt-domain.h:2394 + PerfParamPageFaultsMin = "page_faults_min" + // PerfParamPageFaultsMaj as defined in libvirt/libvirt-domain.h:2404 + PerfParamPageFaultsMaj = "page_faults_maj" + // PerfParamAlignmentFaults as defined in libvirt/libvirt-domain.h:2414 + PerfParamAlignmentFaults = "alignment_faults" + // PerfParamEmulationFaults as defined in libvirt/libvirt-domain.h:2424 + PerfParamEmulationFaults = "emulation_faults" + // DomainBlockCopyBandwidth as defined in libvirt/libvirt-domain.h:2592 + DomainBlockCopyBandwidth = "bandwidth" + // DomainBlockCopyGranularity as defined in libvirt/libvirt-domain.h:2603 + DomainBlockCopyGranularity = "granularity" + // DomainBlockCopyBufSize as defined in libvirt/libvirt-domain.h:2612 + DomainBlockCopyBufSize = "buf-size" + // DomainBlockIotuneTotalBytesSec as defined in libvirt/libvirt-domain.h:2653 + DomainBlockIotuneTotalBytesSec = "total_bytes_sec" + // DomainBlockIotuneReadBytesSec as defined in libvirt/libvirt-domain.h:2661 + DomainBlockIotuneReadBytesSec = "read_bytes_sec" + // DomainBlockIotuneWriteBytesSec as defined in libvirt/libvirt-domain.h:2669 + DomainBlockIotuneWriteBytesSec = "write_bytes_sec" + // DomainBlockIotuneTotalIopsSec as defined in libvirt/libvirt-domain.h:2677 + DomainBlockIotuneTotalIopsSec = "total_iops_sec" + // DomainBlockIotuneReadIopsSec as defined in libvirt/libvirt-domain.h:2685 + DomainBlockIotuneReadIopsSec = "read_iops_sec" + // DomainBlockIotuneWriteIopsSec as defined in libvirt/libvirt-domain.h:2692 + DomainBlockIotuneWriteIopsSec = "write_iops_sec" + // DomainBlockIotuneTotalBytesSecMax as defined in libvirt/libvirt-domain.h:2700 + DomainBlockIotuneTotalBytesSecMax = "total_bytes_sec_max" + // DomainBlockIotuneReadBytesSecMax as defined in libvirt/libvirt-domain.h:2708 + DomainBlockIotuneReadBytesSecMax = "read_bytes_sec_max" + // DomainBlockIotuneWriteBytesSecMax as defined in libvirt/libvirt-domain.h:2716 + DomainBlockIotuneWriteBytesSecMax = "write_bytes_sec_max" + // DomainBlockIotuneTotalIopsSecMax as defined in libvirt/libvirt-domain.h:2724 + DomainBlockIotuneTotalIopsSecMax = "total_iops_sec_max" + // DomainBlockIotuneReadIopsSecMax as defined in libvirt/libvirt-domain.h:2732 + DomainBlockIotuneReadIopsSecMax = "read_iops_sec_max" + // DomainBlockIotuneWriteIopsSecMax as defined in libvirt/libvirt-domain.h:2739 + DomainBlockIotuneWriteIopsSecMax = "write_iops_sec_max" + // DomainBlockIotuneTotalBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2747 + DomainBlockIotuneTotalBytesSecMaxLength = "total_bytes_sec_max_length" + // DomainBlockIotuneReadBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2755 + DomainBlockIotuneReadBytesSecMaxLength = "read_bytes_sec_max_length" + // DomainBlockIotuneWriteBytesSecMaxLength as defined in libvirt/libvirt-domain.h:2763 + DomainBlockIotuneWriteBytesSecMaxLength = "write_bytes_sec_max_length" + // DomainBlockIotuneTotalIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2771 + DomainBlockIotuneTotalIopsSecMaxLength = "total_iops_sec_max_length" + // DomainBlockIotuneReadIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2779 + DomainBlockIotuneReadIopsSecMaxLength = "read_iops_sec_max_length" + // DomainBlockIotuneWriteIopsSecMaxLength as defined in libvirt/libvirt-domain.h:2787 + DomainBlockIotuneWriteIopsSecMaxLength = "write_iops_sec_max_length" + // DomainBlockIotuneSizeIopsSec as defined in libvirt/libvirt-domain.h:2794 + DomainBlockIotuneSizeIopsSec = "size_iops_sec" + // DomainBlockIotuneGroupName as defined in libvirt/libvirt-domain.h:2801 + DomainBlockIotuneGroupName = "group_name" + // KeycodeSetRfb as defined in libvirt/libvirt-domain.h:2882 + KeycodeSetRfb = 0 + // DomainSendKeyMaxKeys as defined in libvirt/libvirt-domain.h:2889 + DomainSendKeyMaxKeys = 16 + // DomainJobOperationStr as defined in libvirt/libvirt-domain.h:3304 + DomainJobOperationStr = "operation" + // DomainJobTimeElapsed as defined in libvirt/libvirt-domain.h:3314 + DomainJobTimeElapsed = "time_elapsed" + // DomainJobTimeElapsedNet as defined in libvirt/libvirt-domain.h:3324 + DomainJobTimeElapsedNet = "time_elapsed_net" + // DomainJobTimeRemaining as defined in libvirt/libvirt-domain.h:3334 + DomainJobTimeRemaining = "time_remaining" + // DomainJobDowntime as defined in libvirt/libvirt-domain.h:3344 + DomainJobDowntime = "downtime" + // DomainJobDowntimeNet as defined in libvirt/libvirt-domain.h:3353 + DomainJobDowntimeNet = "downtime_net" + // DomainJobSetupTime as defined in libvirt/libvirt-domain.h:3362 + DomainJobSetupTime = "setup_time" + // DomainJobDataTotal as defined in libvirt/libvirt-domain.h:3377 + DomainJobDataTotal = "data_total" + // DomainJobDataProcessed as defined in libvirt/libvirt-domain.h:3387 + DomainJobDataProcessed = "data_processed" + // DomainJobDataRemaining as defined in libvirt/libvirt-domain.h:3397 + DomainJobDataRemaining = "data_remaining" + // DomainJobMemoryTotal as defined in libvirt/libvirt-domain.h:3407 + DomainJobMemoryTotal = "memory_total" + // DomainJobMemoryProcessed as defined in libvirt/libvirt-domain.h:3417 + DomainJobMemoryProcessed = "memory_processed" + // DomainJobMemoryRemaining as defined in libvirt/libvirt-domain.h:3427 + DomainJobMemoryRemaining = "memory_remaining" + // DomainJobMemoryConstant as defined in libvirt/libvirt-domain.h:3439 + DomainJobMemoryConstant = "memory_constant" + // DomainJobMemoryNormal as defined in libvirt/libvirt-domain.h:3449 + DomainJobMemoryNormal = "memory_normal" + // DomainJobMemoryNormalBytes as defined in libvirt/libvirt-domain.h:3459 + DomainJobMemoryNormalBytes = "memory_normal_bytes" + // DomainJobMemoryBps as defined in libvirt/libvirt-domain.h:3467 + DomainJobMemoryBps = "memory_bps" + // DomainJobMemoryDirtyRate as defined in libvirt/libvirt-domain.h:3475 + DomainJobMemoryDirtyRate = "memory_dirty_rate" + // DomainJobMemoryPageSize as defined in libvirt/libvirt-domain.h:3486 + DomainJobMemoryPageSize = "memory_page_size" + // DomainJobMemoryIteration as defined in libvirt/libvirt-domain.h:3497 + DomainJobMemoryIteration = "memory_iteration" + // DomainJobMemoryPostcopyReqs as defined in libvirt/libvirt-domain.h:3507 + DomainJobMemoryPostcopyReqs = "memory_postcopy_requests" + // DomainJobDiskTotal as defined in libvirt/libvirt-domain.h:3517 + DomainJobDiskTotal = "disk_total" + // DomainJobDiskProcessed as defined in libvirt/libvirt-domain.h:3527 + DomainJobDiskProcessed = "disk_processed" + // DomainJobDiskRemaining as defined in libvirt/libvirt-domain.h:3537 + DomainJobDiskRemaining = "disk_remaining" + // DomainJobDiskBps as defined in libvirt/libvirt-domain.h:3545 + DomainJobDiskBps = "disk_bps" + // DomainJobCompressionCache as defined in libvirt/libvirt-domain.h:3554 + DomainJobCompressionCache = "compression_cache" + // DomainJobCompressionBytes as defined in libvirt/libvirt-domain.h:3562 + DomainJobCompressionBytes = "compression_bytes" + // DomainJobCompressionPages as defined in libvirt/libvirt-domain.h:3570 + DomainJobCompressionPages = "compression_pages" + // DomainJobCompressionCacheMisses as defined in libvirt/libvirt-domain.h:3579 + DomainJobCompressionCacheMisses = "compression_cache_misses" + // DomainJobCompressionOverflow as defined in libvirt/libvirt-domain.h:3589 + DomainJobCompressionOverflow = "compression_overflow" + // DomainJobAutoConvergeThrottle as defined in libvirt/libvirt-domain.h:3598 + DomainJobAutoConvergeThrottle = "auto_converge_throttle" + // DomainJobSuccess as defined in libvirt/libvirt-domain.h:3606 + DomainJobSuccess = "success" + // DomainJobDiskTempUsed as defined in libvirt/libvirt-domain.h:3613 + DomainJobDiskTempUsed = "disk_temp_used" + // DomainJobDiskTempTotal as defined in libvirt/libvirt-domain.h:3620 + DomainJobDiskTempTotal = "disk_temp_total" + // DomainTunableCPUVcpupin as defined in libvirt/libvirt-domain.h:4175 + DomainTunableCPUVcpupin = "cputune.vcpupin%u" + // DomainTunableCPUEmulatorpin as defined in libvirt/libvirt-domain.h:4183 + DomainTunableCPUEmulatorpin = "cputune.emulatorpin" + // DomainTunableCPUIothreadspin as defined in libvirt/libvirt-domain.h:4192 + DomainTunableCPUIothreadspin = "cputune.iothreadpin%u" + // DomainTunableCPUCpuShares as defined in libvirt/libvirt-domain.h:4200 + DomainTunableCPUCpuShares = "cputune.cpu_shares" + // DomainTunableCPUGlobalPeriod as defined in libvirt/libvirt-domain.h:4208 + DomainTunableCPUGlobalPeriod = "cputune.global_period" + // DomainTunableCPUGlobalQuota as defined in libvirt/libvirt-domain.h:4216 + DomainTunableCPUGlobalQuota = "cputune.global_quota" + // DomainTunableCPUVCPUPeriod as defined in libvirt/libvirt-domain.h:4224 + DomainTunableCPUVCPUPeriod = "cputune.vcpu_period" + // DomainTunableCPUVCPUQuota as defined in libvirt/libvirt-domain.h:4232 + DomainTunableCPUVCPUQuota = "cputune.vcpu_quota" + // DomainTunableCPUEmulatorPeriod as defined in libvirt/libvirt-domain.h:4241 + DomainTunableCPUEmulatorPeriod = "cputune.emulator_period" + // DomainTunableCPUEmulatorQuota as defined in libvirt/libvirt-domain.h:4250 + DomainTunableCPUEmulatorQuota = "cputune.emulator_quota" + // DomainTunableCPUIothreadPeriod as defined in libvirt/libvirt-domain.h:4258 + DomainTunableCPUIothreadPeriod = "cputune.iothread_period" + // DomainTunableCPUIothreadQuota as defined in libvirt/libvirt-domain.h:4266 + DomainTunableCPUIothreadQuota = "cputune.iothread_quota" + // DomainTunableBlkdevDisk as defined in libvirt/libvirt-domain.h:4274 + DomainTunableBlkdevDisk = "blkdeviotune.disk" + // DomainTunableBlkdevTotalBytesSec as defined in libvirt/libvirt-domain.h:4282 + DomainTunableBlkdevTotalBytesSec = "blkdeviotune.total_bytes_sec" + // DomainTunableBlkdevReadBytesSec as defined in libvirt/libvirt-domain.h:4290 + DomainTunableBlkdevReadBytesSec = "blkdeviotune.read_bytes_sec" + // DomainTunableBlkdevWriteBytesSec as defined in libvirt/libvirt-domain.h:4298 + DomainTunableBlkdevWriteBytesSec = "blkdeviotune.write_bytes_sec" + // DomainTunableBlkdevTotalIopsSec as defined in libvirt/libvirt-domain.h:4306 + DomainTunableBlkdevTotalIopsSec = "blkdeviotune.total_iops_sec" + // DomainTunableBlkdevReadIopsSec as defined in libvirt/libvirt-domain.h:4314 + DomainTunableBlkdevReadIopsSec = "blkdeviotune.read_iops_sec" + // DomainTunableBlkdevWriteIopsSec as defined in libvirt/libvirt-domain.h:4322 + DomainTunableBlkdevWriteIopsSec = "blkdeviotune.write_iops_sec" + // DomainTunableBlkdevTotalBytesSecMax as defined in libvirt/libvirt-domain.h:4330 + DomainTunableBlkdevTotalBytesSecMax = "blkdeviotune.total_bytes_sec_max" + // DomainTunableBlkdevReadBytesSecMax as defined in libvirt/libvirt-domain.h:4338 + DomainTunableBlkdevReadBytesSecMax = "blkdeviotune.read_bytes_sec_max" + // DomainTunableBlkdevWriteBytesSecMax as defined in libvirt/libvirt-domain.h:4346 + DomainTunableBlkdevWriteBytesSecMax = "blkdeviotune.write_bytes_sec_max" + // DomainTunableBlkdevTotalIopsSecMax as defined in libvirt/libvirt-domain.h:4354 + DomainTunableBlkdevTotalIopsSecMax = "blkdeviotune.total_iops_sec_max" + // DomainTunableBlkdevReadIopsSecMax as defined in libvirt/libvirt-domain.h:4362 + DomainTunableBlkdevReadIopsSecMax = "blkdeviotune.read_iops_sec_max" + // DomainTunableBlkdevWriteIopsSecMax as defined in libvirt/libvirt-domain.h:4370 + DomainTunableBlkdevWriteIopsSecMax = "blkdeviotune.write_iops_sec_max" + // DomainTunableBlkdevSizeIopsSec as defined in libvirt/libvirt-domain.h:4378 + DomainTunableBlkdevSizeIopsSec = "blkdeviotune.size_iops_sec" + // DomainTunableBlkdevGroupName as defined in libvirt/libvirt-domain.h:4386 + DomainTunableBlkdevGroupName = "blkdeviotune.group_name" + // DomainTunableBlkdevTotalBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4395 + DomainTunableBlkdevTotalBytesSecMaxLength = "blkdeviotune.total_bytes_sec_max_length" + // DomainTunableBlkdevReadBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4404 + DomainTunableBlkdevReadBytesSecMaxLength = "blkdeviotune.read_bytes_sec_max_length" + // DomainTunableBlkdevWriteBytesSecMaxLength as defined in libvirt/libvirt-domain.h:4413 + DomainTunableBlkdevWriteBytesSecMaxLength = "blkdeviotune.write_bytes_sec_max_length" + // DomainTunableBlkdevTotalIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4422 + DomainTunableBlkdevTotalIopsSecMaxLength = "blkdeviotune.total_iops_sec_max_length" + // DomainTunableBlkdevReadIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4431 + DomainTunableBlkdevReadIopsSecMaxLength = "blkdeviotune.read_iops_sec_max_length" + // DomainTunableBlkdevWriteIopsSecMaxLength as defined in libvirt/libvirt-domain.h:4440 + DomainTunableBlkdevWriteIopsSecMaxLength = "blkdeviotune.write_iops_sec_max_length" + // DomainSchedFieldLength as defined in libvirt/libvirt-domain.h:4728 + DomainSchedFieldLength = 80 + // DomainBlkioFieldLength as defined in libvirt/libvirt-domain.h:4772 + DomainBlkioFieldLength = 80 + // DomainMemoryFieldLength as defined in libvirt/libvirt-domain.h:4816 + DomainMemoryFieldLength = 80 + // DomainLaunchSecuritySevMeasurement as defined in libvirt/libvirt-domain.h:4942 + DomainLaunchSecuritySevMeasurement = "sev-measurement" + // NetworkPortBandwidthInAverage as defined in libvirt/libvirt-network.h:391 + NetworkPortBandwidthInAverage = "inbound.average" + // NetworkPortBandwidthInPeak as defined in libvirt/libvirt-network.h:398 + NetworkPortBandwidthInPeak = "inbound.peak" + // NetworkPortBandwidthInBurst as defined in libvirt/libvirt-network.h:405 + NetworkPortBandwidthInBurst = "inbound.burst" + // NetworkPortBandwidthInFloor as defined in libvirt/libvirt-network.h:412 + NetworkPortBandwidthInFloor = "inbound.floor" + // NetworkPortBandwidthOutAverage as defined in libvirt/libvirt-network.h:419 + NetworkPortBandwidthOutAverage = "outbound.average" + // NetworkPortBandwidthOutPeak as defined in libvirt/libvirt-network.h:426 + NetworkPortBandwidthOutPeak = "outbound.peak" + // NetworkPortBandwidthOutBurst as defined in libvirt/libvirt-network.h:433 + NetworkPortBandwidthOutBurst = "outbound.burst" +) + +// ConnectCloseReason as declared in libvirt/libvirt-common.h:119 +type ConnectCloseReason int32 + +// ConnectCloseReason enumeration from libvirt/libvirt-common.h:119 +const ( + ConnectCloseReasonError ConnectCloseReason = iota + ConnectCloseReasonEOF ConnectCloseReason = 1 + ConnectCloseReasonKeepalive ConnectCloseReason = 2 + ConnectCloseReasonClient ConnectCloseReason = 3 +) + +// TypedParameterType as declared in libvirt/libvirt-common.h:138 +type TypedParameterType int32 + +// TypedParameterType enumeration from libvirt/libvirt-common.h:138 +const ( + TypedParamInt TypedParameterType = 1 + TypedParamUint TypedParameterType = 2 + TypedParamLlong TypedParameterType = 3 + TypedParamUllong TypedParameterType = 4 + TypedParamDouble TypedParameterType = 5 + TypedParamBoolean TypedParameterType = 6 + TypedParamString TypedParameterType = 7 +) + +// TypedParameterFlags as declared in libvirt/libvirt-common.h:163 +type TypedParameterFlags int32 + +// TypedParameterFlags enumeration from libvirt/libvirt-common.h:163 +const ( + TypedParamStringOkay TypedParameterFlags = 4 +) + +// NodeSuspendTarget as declared in libvirt/libvirt-host.h:61 +type NodeSuspendTarget int32 + +// NodeSuspendTarget enumeration from libvirt/libvirt-host.h:61 +const ( + NodeSuspendTargetMem NodeSuspendTarget = iota + NodeSuspendTargetDisk NodeSuspendTarget = 1 + NodeSuspendTargetHybrid NodeSuspendTarget = 2 +) + +// NodeGetCPUStatsAllCPUs as declared in libvirt/libvirt-host.h:189 +type NodeGetCPUStatsAllCPUs int32 + +// NodeGetCPUStatsAllCPUs enumeration from libvirt/libvirt-host.h:189 +const ( + NodeCPUStatsAllCpus NodeGetCPUStatsAllCPUs = -1 +) + +// NodeGetMemoryStatsAllCells as declared in libvirt/libvirt-host.h:267 +type NodeGetMemoryStatsAllCells int32 + +// NodeGetMemoryStatsAllCells enumeration from libvirt/libvirt-host.h:267 +const ( + NodeMemoryStatsAllCells NodeGetMemoryStatsAllCells = -1 +) + +// ConnectFlags as declared in libvirt/libvirt-host.h:488 +type ConnectFlags int32 + +// ConnectFlags enumeration from libvirt/libvirt-host.h:488 +const ( + ConnectRo ConnectFlags = 1 + ConnectNoAliases ConnectFlags = 2 +) + +// ConnectCredentialType as declared in libvirt/libvirt-host.h:505 +type ConnectCredentialType int32 + +// ConnectCredentialType enumeration from libvirt/libvirt-host.h:505 +const ( + CredUsername ConnectCredentialType = 1 + CredAuthname ConnectCredentialType = 2 + CredLanguage ConnectCredentialType = 3 + CredCnonce ConnectCredentialType = 4 + CredPassphrase ConnectCredentialType = 5 + CredEchoprompt ConnectCredentialType = 6 + CredNoechoprompt ConnectCredentialType = 7 + CredRealm ConnectCredentialType = 8 + CredExternal ConnectCredentialType = 9 +) + +// CPUCompareResult as declared in libvirt/libvirt-host.h:752 +type CPUCompareResult int32 + +// CPUCompareResult enumeration from libvirt/libvirt-host.h:752 +const ( + CPUCompareError CPUCompareResult = -1 + CPUCompareIncompatible CPUCompareResult = 0 + CPUCompareIdentical CPUCompareResult = 1 + CPUCompareSuperset CPUCompareResult = 2 +) + +// ConnectCompareCPUFlags as declared in libvirt/libvirt-host.h:757 +type ConnectCompareCPUFlags int32 + +// ConnectCompareCPUFlags enumeration from libvirt/libvirt-host.h:757 +const ( + ConnectCompareCPUFailIncompatible ConnectCompareCPUFlags = 1 +) + +// ConnectBaselineCPUFlags as declared in libvirt/libvirt-host.h:783 +type ConnectBaselineCPUFlags int32 + +// ConnectBaselineCPUFlags enumeration from libvirt/libvirt-host.h:783 +const ( + ConnectBaselineCPUExpandFeatures ConnectBaselineCPUFlags = 1 + ConnectBaselineCPUMigratable ConnectBaselineCPUFlags = 2 +) + +// NodeAllocPagesFlags as declared in libvirt/libvirt-host.h:813 +type NodeAllocPagesFlags int32 + +// NodeAllocPagesFlags enumeration from libvirt/libvirt-host.h:813 +const ( + NodeAllocPagesAdd NodeAllocPagesFlags = iota + NodeAllocPagesSet NodeAllocPagesFlags = 1 +) + +// DomainState as declared in libvirt/libvirt-domain.h:70 +type DomainState int32 + +// DomainState enumeration from libvirt/libvirt-domain.h:70 +const ( + DomainNostate DomainState = iota + DomainRunning DomainState = 1 + DomainBlocked DomainState = 2 + DomainPaused DomainState = 3 + DomainShutdown DomainState = 4 + DomainShutoff DomainState = 5 + DomainCrashed DomainState = 6 + DomainPmsuspended DomainState = 7 +) + +// DomainNostateReason as declared in libvirt/libvirt-domain.h:78 +type DomainNostateReason int32 + +// DomainNostateReason enumeration from libvirt/libvirt-domain.h:78 +const ( + DomainNostateUnknown DomainNostateReason = iota +) + +// DomainRunningReason as declared in libvirt/libvirt-domain.h:97 +type DomainRunningReason int32 + +// DomainRunningReason enumeration from libvirt/libvirt-domain.h:97 +const ( + DomainRunningUnknown DomainRunningReason = iota + DomainRunningBooted DomainRunningReason = 1 + DomainRunningMigrated DomainRunningReason = 2 + DomainRunningRestored DomainRunningReason = 3 + DomainRunningFromSnapshot DomainRunningReason = 4 + DomainRunningUnpaused DomainRunningReason = 5 + DomainRunningMigrationCanceled DomainRunningReason = 6 + DomainRunningSaveCanceled DomainRunningReason = 7 + DomainRunningWakeup DomainRunningReason = 8 + DomainRunningCrashed DomainRunningReason = 9 + DomainRunningPostcopy DomainRunningReason = 10 +) + +// DomainBlockedReason as declared in libvirt/libvirt-domain.h:105 +type DomainBlockedReason int32 + +// DomainBlockedReason enumeration from libvirt/libvirt-domain.h:105 +const ( + DomainBlockedUnknown DomainBlockedReason = iota +) + +// DomainPausedReason as declared in libvirt/libvirt-domain.h:126 +type DomainPausedReason int32 + +// DomainPausedReason enumeration from libvirt/libvirt-domain.h:126 +const ( + DomainPausedUnknown DomainPausedReason = iota + DomainPausedUser DomainPausedReason = 1 + DomainPausedMigration DomainPausedReason = 2 + DomainPausedSave DomainPausedReason = 3 + DomainPausedDump DomainPausedReason = 4 + DomainPausedIoerror DomainPausedReason = 5 + DomainPausedWatchdog DomainPausedReason = 6 + DomainPausedFromSnapshot DomainPausedReason = 7 + DomainPausedShuttingDown DomainPausedReason = 8 + DomainPausedSnapshot DomainPausedReason = 9 + DomainPausedCrashed DomainPausedReason = 10 + DomainPausedStartingUp DomainPausedReason = 11 + DomainPausedPostcopy DomainPausedReason = 12 + DomainPausedPostcopyFailed DomainPausedReason = 13 +) + +// DomainShutdownReason as declared in libvirt/libvirt-domain.h:135 +type DomainShutdownReason int32 + +// DomainShutdownReason enumeration from libvirt/libvirt-domain.h:135 +const ( + DomainShutdownUnknown DomainShutdownReason = iota + DomainShutdownUser DomainShutdownReason = 1 +) + +// DomainShutoffReason as declared in libvirt/libvirt-domain.h:152 +type DomainShutoffReason int32 + +// DomainShutoffReason enumeration from libvirt/libvirt-domain.h:152 +const ( + DomainShutoffUnknown DomainShutoffReason = iota + DomainShutoffShutdown DomainShutoffReason = 1 + DomainShutoffDestroyed DomainShutoffReason = 2 + DomainShutoffCrashed DomainShutoffReason = 3 + DomainShutoffMigrated DomainShutoffReason = 4 + DomainShutoffSaved DomainShutoffReason = 5 + DomainShutoffFailed DomainShutoffReason = 6 + DomainShutoffFromSnapshot DomainShutoffReason = 7 + DomainShutoffDaemon DomainShutoffReason = 8 +) + +// DomainCrashedReason as declared in libvirt/libvirt-domain.h:161 +type DomainCrashedReason int32 + +// DomainCrashedReason enumeration from libvirt/libvirt-domain.h:161 +const ( + DomainCrashedUnknown DomainCrashedReason = iota + DomainCrashedPanicked DomainCrashedReason = 1 +) + +// DomainPMSuspendedReason as declared in libvirt/libvirt-domain.h:169 +type DomainPMSuspendedReason int32 + +// DomainPMSuspendedReason enumeration from libvirt/libvirt-domain.h:169 +const ( + DomainPmsuspendedUnknown DomainPMSuspendedReason = iota +) + +// DomainPMSuspendedDiskReason as declared in libvirt/libvirt-domain.h:177 +type DomainPMSuspendedDiskReason int32 + +// DomainPMSuspendedDiskReason enumeration from libvirt/libvirt-domain.h:177 +const ( + DomainPmsuspendedDiskUnknown DomainPMSuspendedDiskReason = iota +) + +// DomainControlState as declared in libvirt/libvirt-domain.h:197 +type DomainControlState int32 + +// DomainControlState enumeration from libvirt/libvirt-domain.h:197 +const ( + DomainControlOk DomainControlState = iota + DomainControlJob DomainControlState = 1 + DomainControlOccupied DomainControlState = 2 + DomainControlError DomainControlState = 3 +) + +// DomainControlErrorReason as declared in libvirt/libvirt-domain.h:217 +type DomainControlErrorReason int32 + +// DomainControlErrorReason enumeration from libvirt/libvirt-domain.h:217 +const ( + DomainControlErrorReasonNone DomainControlErrorReason = iota + DomainControlErrorReasonUnknown DomainControlErrorReason = 1 + DomainControlErrorReasonMonitor DomainControlErrorReason = 2 + DomainControlErrorReasonInternal DomainControlErrorReason = 3 +) + +// DomainModificationImpact as declared in libvirt/libvirt-domain.h:265 +type DomainModificationImpact int32 + +// DomainModificationImpact enumeration from libvirt/libvirt-domain.h:265 +const ( + DomainAffectCurrent DomainModificationImpact = iota + DomainAffectLive DomainModificationImpact = 1 + DomainAffectConfig DomainModificationImpact = 2 +) + +// DomainCreateFlags as declared in libvirt/libvirt-domain.h:305 +type DomainCreateFlags int32 + +// DomainCreateFlags enumeration from libvirt/libvirt-domain.h:305 +const ( + DomainNone DomainCreateFlags = iota + DomainStartPaused DomainCreateFlags = 1 + DomainStartAutodestroy DomainCreateFlags = 2 + DomainStartBypassCache DomainCreateFlags = 4 + DomainStartForceBoot DomainCreateFlags = 8 + DomainStartValidate DomainCreateFlags = 16 +) + +// DomainMemoryStatTags as declared in libvirt/libvirt-domain.h:660 +type DomainMemoryStatTags int32 + +// DomainMemoryStatTags enumeration from libvirt/libvirt-domain.h:660 +const ( + DomainMemoryStatSwapIn DomainMemoryStatTags = iota + DomainMemoryStatSwapOut DomainMemoryStatTags = 1 + DomainMemoryStatMajorFault DomainMemoryStatTags = 2 + DomainMemoryStatMinorFault DomainMemoryStatTags = 3 + DomainMemoryStatUnused DomainMemoryStatTags = 4 + DomainMemoryStatAvailable DomainMemoryStatTags = 5 + DomainMemoryStatActualBalloon DomainMemoryStatTags = 6 + DomainMemoryStatRss DomainMemoryStatTags = 7 + DomainMemoryStatUsable DomainMemoryStatTags = 8 + DomainMemoryStatLastUpdate DomainMemoryStatTags = 9 + DomainMemoryStatDiskCaches DomainMemoryStatTags = 10 + DomainMemoryStatHugetlbPgalloc DomainMemoryStatTags = 11 + DomainMemoryStatHugetlbPgfail DomainMemoryStatTags = 12 + DomainMemoryStatNr DomainMemoryStatTags = 13 +) + +// DomainCoreDumpFlags as declared in libvirt/libvirt-domain.h:679 +type DomainCoreDumpFlags int32 + +// DomainCoreDumpFlags enumeration from libvirt/libvirt-domain.h:679 +const ( + DumpCrash DomainCoreDumpFlags = 1 + DumpLive DomainCoreDumpFlags = 2 + DumpBypassCache DomainCoreDumpFlags = 4 + DumpReset DomainCoreDumpFlags = 8 + DumpMemoryOnly DomainCoreDumpFlags = 16 +) + +// DomainCoreDumpFormat as declared in libvirt/libvirt-domain.h:702 +type DomainCoreDumpFormat int32 + +// DomainCoreDumpFormat enumeration from libvirt/libvirt-domain.h:702 +const ( + DomainCoreDumpFormatRaw DomainCoreDumpFormat = iota + DomainCoreDumpFormatKdumpZlib DomainCoreDumpFormat = 1 + DomainCoreDumpFormatKdumpLzo DomainCoreDumpFormat = 2 + DomainCoreDumpFormatKdumpSnappy DomainCoreDumpFormat = 3 +) + +// DomainMigrateFlags as declared in libvirt/libvirt-domain.h:852 +type DomainMigrateFlags int32 + +// DomainMigrateFlags enumeration from libvirt/libvirt-domain.h:852 +const ( + MigrateLive DomainMigrateFlags = 1 + MigratePeer2peer DomainMigrateFlags = 2 + MigrateTunnelled DomainMigrateFlags = 4 + MigratePersistDest DomainMigrateFlags = 8 + MigrateUndefineSource DomainMigrateFlags = 16 + MigratePaused DomainMigrateFlags = 32 + MigrateNonSharedDisk DomainMigrateFlags = 64 + MigrateNonSharedInc DomainMigrateFlags = 128 + MigrateChangeProtection DomainMigrateFlags = 256 + MigrateUnsafe DomainMigrateFlags = 512 + MigrateOffline DomainMigrateFlags = 1024 + MigrateCompressed DomainMigrateFlags = 2048 + MigrateAbortOnError DomainMigrateFlags = 4096 + MigrateAutoConverge DomainMigrateFlags = 8192 + MigrateRdmaPinAll DomainMigrateFlags = 16384 + MigratePostcopy DomainMigrateFlags = 32768 + MigrateTLS DomainMigrateFlags = 65536 + MigrateParallel DomainMigrateFlags = 131072 +) + +// DomainMigrateMaxSpeedFlags as declared in libvirt/libvirt-domain.h:1118 +type DomainMigrateMaxSpeedFlags int32 + +// DomainMigrateMaxSpeedFlags enumeration from libvirt/libvirt-domain.h:1118 +const ( + DomainMigrateMaxSpeedPostcopy DomainMigrateMaxSpeedFlags = 1 +) + +// DomainShutdownFlagValues as declared in libvirt/libvirt-domain.h:1184 +type DomainShutdownFlagValues int32 + +// DomainShutdownFlagValues enumeration from libvirt/libvirt-domain.h:1184 +const ( + DomainShutdownDefault DomainShutdownFlagValues = iota + DomainShutdownAcpiPowerBtn DomainShutdownFlagValues = 1 + DomainShutdownGuestAgent DomainShutdownFlagValues = 2 + DomainShutdownInitctl DomainShutdownFlagValues = 4 + DomainShutdownSignal DomainShutdownFlagValues = 8 + DomainShutdownParavirt DomainShutdownFlagValues = 16 +) + +// DomainRebootFlagValues as declared in libvirt/libvirt-domain.h:1197 +type DomainRebootFlagValues int32 + +// DomainRebootFlagValues enumeration from libvirt/libvirt-domain.h:1197 +const ( + DomainRebootDefault DomainRebootFlagValues = iota + DomainRebootAcpiPowerBtn DomainRebootFlagValues = 1 + DomainRebootGuestAgent DomainRebootFlagValues = 2 + DomainRebootInitctl DomainRebootFlagValues = 4 + DomainRebootSignal DomainRebootFlagValues = 8 + DomainRebootParavirt DomainRebootFlagValues = 16 +) + +// DomainDestroyFlagsValues as declared in libvirt/libvirt-domain.h:1215 +type DomainDestroyFlagsValues int32 + +// DomainDestroyFlagsValues enumeration from libvirt/libvirt-domain.h:1215 +const ( + DomainDestroyDefault DomainDestroyFlagsValues = iota + DomainDestroyGraceful DomainDestroyFlagsValues = 1 +) + +// DomainSaveRestoreFlags as declared in libvirt/libvirt-domain.h:1247 +type DomainSaveRestoreFlags int32 + +// DomainSaveRestoreFlags enumeration from libvirt/libvirt-domain.h:1247 +const ( + DomainSaveBypassCache DomainSaveRestoreFlags = 1 + DomainSaveRunning DomainSaveRestoreFlags = 2 + DomainSavePaused DomainSaveRestoreFlags = 4 +) + +// DomainMemoryModFlags as declared in libvirt/libvirt-domain.h:1503 +type DomainMemoryModFlags int32 + +// DomainMemoryModFlags enumeration from libvirt/libvirt-domain.h:1503 +const ( + DomainMemCurrent DomainMemoryModFlags = iota + DomainMemLive DomainMemoryModFlags = 1 + DomainMemConfig DomainMemoryModFlags = 2 + DomainMemMaximum DomainMemoryModFlags = 4 +) + +// DomainNumatuneMemMode as declared in libvirt/libvirt-domain.h:1521 +type DomainNumatuneMemMode int32 + +// DomainNumatuneMemMode enumeration from libvirt/libvirt-domain.h:1521 +const ( + DomainNumatuneMemStrict DomainNumatuneMemMode = iota + DomainNumatuneMemPreferred DomainNumatuneMemMode = 1 + DomainNumatuneMemInterleave DomainNumatuneMemMode = 2 +) + +// DomainMetadataType as declared in libvirt/libvirt-domain.h:1583 +type DomainMetadataType int32 + +// DomainMetadataType enumeration from libvirt/libvirt-domain.h:1583 +const ( + DomainMetadataDescription DomainMetadataType = iota + DomainMetadataTitle DomainMetadataType = 1 + DomainMetadataElement DomainMetadataType = 2 +) + +// DomainXMLFlags as declared in libvirt/libvirt-domain.h:1613 +type DomainXMLFlags int32 + +// DomainXMLFlags enumeration from libvirt/libvirt-domain.h:1613 +const ( + DomainXMLSecure DomainXMLFlags = 1 + DomainXMLInactive DomainXMLFlags = 2 + DomainXMLUpdateCPU DomainXMLFlags = 4 + DomainXMLMigratable DomainXMLFlags = 8 +) + +// DomainSaveImageXMLFlags as declared in libvirt/libvirt-domain.h:1617 +type DomainSaveImageXMLFlags int32 + +// DomainSaveImageXMLFlags enumeration from libvirt/libvirt-domain.h:1617 +const ( + DomainSaveImageXMLSecure DomainSaveImageXMLFlags = 1 +) + +// DomainBlockResizeFlags as declared in libvirt/libvirt-domain.h:1722 +type DomainBlockResizeFlags int32 + +// DomainBlockResizeFlags enumeration from libvirt/libvirt-domain.h:1722 +const ( + DomainBlockResizeBytes DomainBlockResizeFlags = 1 +) + +// DomainMemoryFlags as declared in libvirt/libvirt-domain.h:1785 +type DomainMemoryFlags int32 + +// DomainMemoryFlags enumeration from libvirt/libvirt-domain.h:1785 +const ( + MemoryVirtual DomainMemoryFlags = 1 + MemoryPhysical DomainMemoryFlags = 2 +) + +// DomainDefineFlags as declared in libvirt/libvirt-domain.h:1795 +type DomainDefineFlags int32 + +// DomainDefineFlags enumeration from libvirt/libvirt-domain.h:1795 +const ( + DomainDefineValidate DomainDefineFlags = 1 +) + +// DomainUndefineFlagsValues as declared in libvirt/libvirt-domain.h:1822 +type DomainUndefineFlagsValues int32 + +// DomainUndefineFlagsValues enumeration from libvirt/libvirt-domain.h:1822 +const ( + DomainUndefineManagedSave DomainUndefineFlagsValues = 1 + DomainUndefineSnapshotsMetadata DomainUndefineFlagsValues = 2 + DomainUndefineNvram DomainUndefineFlagsValues = 4 + DomainUndefineKeepNvram DomainUndefineFlagsValues = 8 + DomainUndefineCheckpointsMetadata DomainUndefineFlagsValues = 16 +) + +// ConnectListAllDomainsFlags as declared in libvirt/libvirt-domain.h:1861 +type ConnectListAllDomainsFlags int32 + +// ConnectListAllDomainsFlags enumeration from libvirt/libvirt-domain.h:1861 +const ( + ConnectListDomainsActive ConnectListAllDomainsFlags = 1 + ConnectListDomainsInactive ConnectListAllDomainsFlags = 2 + ConnectListDomainsPersistent ConnectListAllDomainsFlags = 4 + ConnectListDomainsTransient ConnectListAllDomainsFlags = 8 + ConnectListDomainsRunning ConnectListAllDomainsFlags = 16 + ConnectListDomainsPaused ConnectListAllDomainsFlags = 32 + ConnectListDomainsShutoff ConnectListAllDomainsFlags = 64 + ConnectListDomainsOther ConnectListAllDomainsFlags = 128 + ConnectListDomainsManagedsave ConnectListAllDomainsFlags = 256 + ConnectListDomainsNoManagedsave ConnectListAllDomainsFlags = 512 + ConnectListDomainsAutostart ConnectListAllDomainsFlags = 1024 + ConnectListDomainsNoAutostart ConnectListAllDomainsFlags = 2048 + ConnectListDomainsHasSnapshot ConnectListAllDomainsFlags = 4096 + ConnectListDomainsNoSnapshot ConnectListAllDomainsFlags = 8192 + ConnectListDomainsHasCheckpoint ConnectListAllDomainsFlags = 16384 + ConnectListDomainsNoCheckpoint ConnectListAllDomainsFlags = 32768 +) + +// VCPUState as declared in libvirt/libvirt-domain.h:1892 +type VCPUState int32 + +// VCPUState enumeration from libvirt/libvirt-domain.h:1892 +const ( + VCPUOffline VCPUState = iota + VCPURunning VCPUState = 1 + VCPUBlocked VCPUState = 2 +) + +// DomainVCPUFlags as declared in libvirt/libvirt-domain.h:1914 +type DomainVCPUFlags int32 + +// DomainVCPUFlags enumeration from libvirt/libvirt-domain.h:1914 +const ( + DomainVCPUCurrent DomainVCPUFlags = iota + DomainVCPULive DomainVCPUFlags = 1 + DomainVCPUConfig DomainVCPUFlags = 2 + DomainVCPUMaximum DomainVCPUFlags = 4 + DomainVCPUGuest DomainVCPUFlags = 8 + DomainVCPUHotpluggable DomainVCPUFlags = 16 +) + +// DomainDeviceModifyFlags as declared in libvirt/libvirt-domain.h:2131 +type DomainDeviceModifyFlags int32 + +// DomainDeviceModifyFlags enumeration from libvirt/libvirt-domain.h:2131 +const ( + DomainDeviceModifyCurrent DomainDeviceModifyFlags = iota + DomainDeviceModifyLive DomainDeviceModifyFlags = 1 + DomainDeviceModifyConfig DomainDeviceModifyFlags = 2 + DomainDeviceModifyForce DomainDeviceModifyFlags = 4 +) + +// DomainStatsTypes as declared in libvirt/libvirt-domain.h:2164 +type DomainStatsTypes int32 + +// DomainStatsTypes enumeration from libvirt/libvirt-domain.h:2164 +const ( + DomainStatsState DomainStatsTypes = 1 + DomainStatsCPUTotal DomainStatsTypes = 2 + DomainStatsBalloon DomainStatsTypes = 4 + DomainStatsVCPU DomainStatsTypes = 8 + DomainStatsInterface DomainStatsTypes = 16 + DomainStatsBlock DomainStatsTypes = 32 + DomainStatsPerf DomainStatsTypes = 64 + DomainStatsIothread DomainStatsTypes = 128 + DomainStatsMemory DomainStatsTypes = 256 +) + +// ConnectGetAllDomainStatsFlags as declared in libvirt/libvirt-domain.h:2182 +type ConnectGetAllDomainStatsFlags int32 + +// ConnectGetAllDomainStatsFlags enumeration from libvirt/libvirt-domain.h:2182 +const ( + ConnectGetAllDomainsStatsActive ConnectGetAllDomainStatsFlags = 1 + ConnectGetAllDomainsStatsInactive ConnectGetAllDomainStatsFlags = 2 + ConnectGetAllDomainsStatsPersistent ConnectGetAllDomainStatsFlags = 4 + ConnectGetAllDomainsStatsTransient ConnectGetAllDomainStatsFlags = 8 + ConnectGetAllDomainsStatsRunning ConnectGetAllDomainStatsFlags = 16 + ConnectGetAllDomainsStatsPaused ConnectGetAllDomainStatsFlags = 32 + ConnectGetAllDomainsStatsShutoff ConnectGetAllDomainStatsFlags = 64 + ConnectGetAllDomainsStatsOther ConnectGetAllDomainStatsFlags = 128 + ConnectGetAllDomainsStatsNowait ConnectGetAllDomainStatsFlags = 536870912 + ConnectGetAllDomainsStatsBacking ConnectGetAllDomainStatsFlags = 1073741824 + ConnectGetAllDomainsStatsEnforceStats ConnectGetAllDomainStatsFlags = -2147483648 +) + +// DomainBlockJobType as declared in libvirt/libvirt-domain.h:2470 +type DomainBlockJobType int32 + +// DomainBlockJobType enumeration from libvirt/libvirt-domain.h:2470 +const ( + DomainBlockJobTypeUnknown DomainBlockJobType = iota + DomainBlockJobTypePull DomainBlockJobType = 1 + DomainBlockJobTypeCopy DomainBlockJobType = 2 + DomainBlockJobTypeCommit DomainBlockJobType = 3 + DomainBlockJobTypeActiveCommit DomainBlockJobType = 4 + DomainBlockJobTypeBackup DomainBlockJobType = 5 +) + +// DomainBlockJobAbortFlags as declared in libvirt/libvirt-domain.h:2482 +type DomainBlockJobAbortFlags int32 + +// DomainBlockJobAbortFlags enumeration from libvirt/libvirt-domain.h:2482 +const ( + DomainBlockJobAbortAsync DomainBlockJobAbortFlags = 1 + DomainBlockJobAbortPivot DomainBlockJobAbortFlags = 2 +) + +// DomainBlockJobInfoFlags as declared in libvirt/libvirt-domain.h:2491 +type DomainBlockJobInfoFlags int32 + +// DomainBlockJobInfoFlags enumeration from libvirt/libvirt-domain.h:2491 +const ( + DomainBlockJobInfoBandwidthBytes DomainBlockJobInfoFlags = 1 +) + +// DomainBlockJobSetSpeedFlags as declared in libvirt/libvirt-domain.h:2520 +type DomainBlockJobSetSpeedFlags int32 + +// DomainBlockJobSetSpeedFlags enumeration from libvirt/libvirt-domain.h:2520 +const ( + DomainBlockJobSpeedBandwidthBytes DomainBlockJobSetSpeedFlags = 1 +) + +// DomainBlockPullFlags as declared in libvirt/libvirt-domain.h:2530 +type DomainBlockPullFlags int32 + +// DomainBlockPullFlags enumeration from libvirt/libvirt-domain.h:2530 +const ( + DomainBlockPullBandwidthBytes DomainBlockPullFlags = 64 +) + +// DomainBlockRebaseFlags as declared in libvirt/libvirt-domain.h:2554 +type DomainBlockRebaseFlags int32 + +// DomainBlockRebaseFlags enumeration from libvirt/libvirt-domain.h:2554 +const ( + DomainBlockRebaseShallow DomainBlockRebaseFlags = 1 + DomainBlockRebaseReuseExt DomainBlockRebaseFlags = 2 + DomainBlockRebaseCopyRaw DomainBlockRebaseFlags = 4 + DomainBlockRebaseCopy DomainBlockRebaseFlags = 8 + DomainBlockRebaseRelative DomainBlockRebaseFlags = 16 + DomainBlockRebaseCopyDev DomainBlockRebaseFlags = 32 + DomainBlockRebaseBandwidthBytes DomainBlockRebaseFlags = 64 +) + +// DomainBlockCopyFlags as declared in libvirt/libvirt-domain.h:2573 +type DomainBlockCopyFlags int32 + +// DomainBlockCopyFlags enumeration from libvirt/libvirt-domain.h:2573 +const ( + DomainBlockCopyShallow DomainBlockCopyFlags = 1 + DomainBlockCopyReuseExt DomainBlockCopyFlags = 2 + DomainBlockCopyTransientJob DomainBlockCopyFlags = 4 +) + +// DomainBlockCommitFlags as declared in libvirt/libvirt-domain.h:2638 +type DomainBlockCommitFlags int32 + +// DomainBlockCommitFlags enumeration from libvirt/libvirt-domain.h:2638 +const ( + DomainBlockCommitShallow DomainBlockCommitFlags = 1 + DomainBlockCommitDelete DomainBlockCommitFlags = 2 + DomainBlockCommitActive DomainBlockCommitFlags = 4 + DomainBlockCommitRelative DomainBlockCommitFlags = 8 + DomainBlockCommitBandwidthBytes DomainBlockCommitFlags = 16 +) + +// DomainDiskErrorCode as declared in libvirt/libvirt-domain.h:2829 +type DomainDiskErrorCode int32 + +// DomainDiskErrorCode enumeration from libvirt/libvirt-domain.h:2829 +const ( + DomainDiskErrorNone DomainDiskErrorCode = iota + DomainDiskErrorUnspec DomainDiskErrorCode = 1 + DomainDiskErrorNoSpace DomainDiskErrorCode = 2 +) + +// KeycodeSet as declared in libvirt/libvirt-domain.h:2875 +type KeycodeSet int32 + +// KeycodeSet enumeration from libvirt/libvirt-domain.h:2875 +const ( + KeycodeSetLinux KeycodeSet = iota + KeycodeSetXt KeycodeSet = 1 + KeycodeSetAtset1 KeycodeSet = 2 + KeycodeSetAtset2 KeycodeSet = 3 + KeycodeSetAtset3 KeycodeSet = 4 + KeycodeSetOsx KeycodeSet = 5 + KeycodeSetXtKbd KeycodeSet = 6 + KeycodeSetUsb KeycodeSet = 7 + KeycodeSetWin32 KeycodeSet = 8 + KeycodeSetQnum KeycodeSet = 9 +) + +// DomainProcessSignal as declared in libvirt/libvirt-domain.h:2984 +type DomainProcessSignal int32 + +// DomainProcessSignal enumeration from libvirt/libvirt-domain.h:2984 +const ( + DomainProcessSignalNop DomainProcessSignal = iota + DomainProcessSignalHup DomainProcessSignal = 1 + DomainProcessSignalInt DomainProcessSignal = 2 + DomainProcessSignalQuit DomainProcessSignal = 3 + DomainProcessSignalIll DomainProcessSignal = 4 + DomainProcessSignalTrap DomainProcessSignal = 5 + DomainProcessSignalAbrt DomainProcessSignal = 6 + DomainProcessSignalBus DomainProcessSignal = 7 + DomainProcessSignalFpe DomainProcessSignal = 8 + DomainProcessSignalKill DomainProcessSignal = 9 + DomainProcessSignalUsr1 DomainProcessSignal = 10 + DomainProcessSignalSegv DomainProcessSignal = 11 + DomainProcessSignalUsr2 DomainProcessSignal = 12 + DomainProcessSignalPipe DomainProcessSignal = 13 + DomainProcessSignalAlrm DomainProcessSignal = 14 + DomainProcessSignalTerm DomainProcessSignal = 15 + DomainProcessSignalStkflt DomainProcessSignal = 16 + DomainProcessSignalChld DomainProcessSignal = 17 + DomainProcessSignalCont DomainProcessSignal = 18 + DomainProcessSignalStop DomainProcessSignal = 19 + DomainProcessSignalTstp DomainProcessSignal = 20 + DomainProcessSignalTtin DomainProcessSignal = 21 + DomainProcessSignalTtou DomainProcessSignal = 22 + DomainProcessSignalUrg DomainProcessSignal = 23 + DomainProcessSignalXcpu DomainProcessSignal = 24 + DomainProcessSignalXfsz DomainProcessSignal = 25 + DomainProcessSignalVtalrm DomainProcessSignal = 26 + DomainProcessSignalProf DomainProcessSignal = 27 + DomainProcessSignalWinch DomainProcessSignal = 28 + DomainProcessSignalPoll DomainProcessSignal = 29 + DomainProcessSignalPwr DomainProcessSignal = 30 + DomainProcessSignalSys DomainProcessSignal = 31 + DomainProcessSignalRt0 DomainProcessSignal = 32 + DomainProcessSignalRt1 DomainProcessSignal = 33 + DomainProcessSignalRt2 DomainProcessSignal = 34 + DomainProcessSignalRt3 DomainProcessSignal = 35 + DomainProcessSignalRt4 DomainProcessSignal = 36 + DomainProcessSignalRt5 DomainProcessSignal = 37 + DomainProcessSignalRt6 DomainProcessSignal = 38 + DomainProcessSignalRt7 DomainProcessSignal = 39 + DomainProcessSignalRt8 DomainProcessSignal = 40 + DomainProcessSignalRt9 DomainProcessSignal = 41 + DomainProcessSignalRt10 DomainProcessSignal = 42 + DomainProcessSignalRt11 DomainProcessSignal = 43 + DomainProcessSignalRt12 DomainProcessSignal = 44 + DomainProcessSignalRt13 DomainProcessSignal = 45 + DomainProcessSignalRt14 DomainProcessSignal = 46 + DomainProcessSignalRt15 DomainProcessSignal = 47 + DomainProcessSignalRt16 DomainProcessSignal = 48 + DomainProcessSignalRt17 DomainProcessSignal = 49 + DomainProcessSignalRt18 DomainProcessSignal = 50 + DomainProcessSignalRt19 DomainProcessSignal = 51 + DomainProcessSignalRt20 DomainProcessSignal = 52 + DomainProcessSignalRt21 DomainProcessSignal = 53 + DomainProcessSignalRt22 DomainProcessSignal = 54 + DomainProcessSignalRt23 DomainProcessSignal = 55 + DomainProcessSignalRt24 DomainProcessSignal = 56 + DomainProcessSignalRt25 DomainProcessSignal = 57 + DomainProcessSignalRt26 DomainProcessSignal = 58 + DomainProcessSignalRt27 DomainProcessSignal = 59 + DomainProcessSignalRt28 DomainProcessSignal = 60 + DomainProcessSignalRt29 DomainProcessSignal = 61 + DomainProcessSignalRt30 DomainProcessSignal = 62 + DomainProcessSignalRt31 DomainProcessSignal = 63 + DomainProcessSignalRt32 DomainProcessSignal = 64 +) + +// DomainEventType as declared in libvirt/libvirt-domain.h:3022 +type DomainEventType int32 + +// DomainEventType enumeration from libvirt/libvirt-domain.h:3022 +const ( + DomainEventDefined DomainEventType = iota + DomainEventUndefined DomainEventType = 1 + DomainEventStarted DomainEventType = 2 + DomainEventSuspended DomainEventType = 3 + DomainEventResumed DomainEventType = 4 + DomainEventStopped DomainEventType = 5 + DomainEventShutdown DomainEventType = 6 + DomainEventPmsuspended DomainEventType = 7 + DomainEventCrashed DomainEventType = 8 +) + +// DomainEventDefinedDetailType as declared in libvirt/libvirt-domain.h:3038 +type DomainEventDefinedDetailType int32 + +// DomainEventDefinedDetailType enumeration from libvirt/libvirt-domain.h:3038 +const ( + DomainEventDefinedAdded DomainEventDefinedDetailType = iota + DomainEventDefinedUpdated DomainEventDefinedDetailType = 1 + DomainEventDefinedRenamed DomainEventDefinedDetailType = 2 + DomainEventDefinedFromSnapshot DomainEventDefinedDetailType = 3 +) + +// DomainEventUndefinedDetailType as declared in libvirt/libvirt-domain.h:3052 +type DomainEventUndefinedDetailType int32 + +// DomainEventUndefinedDetailType enumeration from libvirt/libvirt-domain.h:3052 +const ( + DomainEventUndefinedRemoved DomainEventUndefinedDetailType = iota + DomainEventUndefinedRenamed DomainEventUndefinedDetailType = 1 +) + +// DomainEventStartedDetailType as declared in libvirt/libvirt-domain.h:3069 +type DomainEventStartedDetailType int32 + +// DomainEventStartedDetailType enumeration from libvirt/libvirt-domain.h:3069 +const ( + DomainEventStartedBooted DomainEventStartedDetailType = iota + DomainEventStartedMigrated DomainEventStartedDetailType = 1 + DomainEventStartedRestored DomainEventStartedDetailType = 2 + DomainEventStartedFromSnapshot DomainEventStartedDetailType = 3 + DomainEventStartedWakeup DomainEventStartedDetailType = 4 +) + +// DomainEventSuspendedDetailType as declared in libvirt/libvirt-domain.h:3090 +type DomainEventSuspendedDetailType int32 + +// DomainEventSuspendedDetailType enumeration from libvirt/libvirt-domain.h:3090 +const ( + DomainEventSuspendedPaused DomainEventSuspendedDetailType = iota + DomainEventSuspendedMigrated DomainEventSuspendedDetailType = 1 + DomainEventSuspendedIoerror DomainEventSuspendedDetailType = 2 + DomainEventSuspendedWatchdog DomainEventSuspendedDetailType = 3 + DomainEventSuspendedRestored DomainEventSuspendedDetailType = 4 + DomainEventSuspendedFromSnapshot DomainEventSuspendedDetailType = 5 + DomainEventSuspendedAPIError DomainEventSuspendedDetailType = 6 + DomainEventSuspendedPostcopy DomainEventSuspendedDetailType = 7 + DomainEventSuspendedPostcopyFailed DomainEventSuspendedDetailType = 8 +) + +// DomainEventResumedDetailType as declared in libvirt/libvirt-domain.h:3107 +type DomainEventResumedDetailType int32 + +// DomainEventResumedDetailType enumeration from libvirt/libvirt-domain.h:3107 +const ( + DomainEventResumedUnpaused DomainEventResumedDetailType = iota + DomainEventResumedMigrated DomainEventResumedDetailType = 1 + DomainEventResumedFromSnapshot DomainEventResumedDetailType = 2 + DomainEventResumedPostcopy DomainEventResumedDetailType = 3 +) + +// DomainEventStoppedDetailType as declared in libvirt/libvirt-domain.h:3126 +type DomainEventStoppedDetailType int32 + +// DomainEventStoppedDetailType enumeration from libvirt/libvirt-domain.h:3126 +const ( + DomainEventStoppedShutdown DomainEventStoppedDetailType = iota + DomainEventStoppedDestroyed DomainEventStoppedDetailType = 1 + DomainEventStoppedCrashed DomainEventStoppedDetailType = 2 + DomainEventStoppedMigrated DomainEventStoppedDetailType = 3 + DomainEventStoppedSaved DomainEventStoppedDetailType = 4 + DomainEventStoppedFailed DomainEventStoppedDetailType = 5 + DomainEventStoppedFromSnapshot DomainEventStoppedDetailType = 6 +) + +// DomainEventShutdownDetailType as declared in libvirt/libvirt-domain.h:3149 +type DomainEventShutdownDetailType int32 + +// DomainEventShutdownDetailType enumeration from libvirt/libvirt-domain.h:3149 +const ( + DomainEventShutdownFinished DomainEventShutdownDetailType = iota + DomainEventShutdownGuest DomainEventShutdownDetailType = 1 + DomainEventShutdownHost DomainEventShutdownDetailType = 2 +) + +// DomainEventPMSuspendedDetailType as declared in libvirt/libvirt-domain.h:3163 +type DomainEventPMSuspendedDetailType int32 + +// DomainEventPMSuspendedDetailType enumeration from libvirt/libvirt-domain.h:3163 +const ( + DomainEventPmsuspendedMemory DomainEventPMSuspendedDetailType = iota + DomainEventPmsuspendedDisk DomainEventPMSuspendedDetailType = 1 +) + +// DomainEventCrashedDetailType as declared in libvirt/libvirt-domain.h:3176 +type DomainEventCrashedDetailType int32 + +// DomainEventCrashedDetailType enumeration from libvirt/libvirt-domain.h:3176 +const ( + DomainEventCrashedPanicked DomainEventCrashedDetailType = iota +) + +// DomainJobType as declared in libvirt/libvirt-domain.h:3220 +type DomainJobType int32 + +// DomainJobType enumeration from libvirt/libvirt-domain.h:3220 +const ( + DomainJobNone DomainJobType = iota + DomainJobBounded DomainJobType = 1 + DomainJobUnbounded DomainJobType = 2 + DomainJobCompleted DomainJobType = 3 + DomainJobFailed DomainJobType = 4 + DomainJobCancelled DomainJobType = 5 +) + +// DomainGetJobStatsFlags as declared in libvirt/libvirt-domain.h:3269 +type DomainGetJobStatsFlags int32 + +// DomainGetJobStatsFlags enumeration from libvirt/libvirt-domain.h:3269 +const ( + DomainJobStatsCompleted DomainGetJobStatsFlags = 1 + DomainJobStatsKeepCompleted DomainGetJobStatsFlags = 2 +) + +// DomainJobOperation as declared in libvirt/libvirt-domain.h:3295 +type DomainJobOperation int32 + +// DomainJobOperation enumeration from libvirt/libvirt-domain.h:3295 +const ( + DomainJobOperationStrUnknown DomainJobOperation = iota + DomainJobOperationStrStart DomainJobOperation = 1 + DomainJobOperationStrSave DomainJobOperation = 2 + DomainJobOperationStrRestore DomainJobOperation = 3 + DomainJobOperationStrMigrationIn DomainJobOperation = 4 + DomainJobOperationStrMigrationOut DomainJobOperation = 5 + DomainJobOperationStrSnapshot DomainJobOperation = 6 + DomainJobOperationStrSnapshotRevert DomainJobOperation = 7 + DomainJobOperationStrDump DomainJobOperation = 8 + DomainJobOperationStrBackup DomainJobOperation = 9 +) + +// DomainEventWatchdogAction as declared in libvirt/libvirt-domain.h:3670 +type DomainEventWatchdogAction int32 + +// DomainEventWatchdogAction enumeration from libvirt/libvirt-domain.h:3670 +const ( + DomainEventWatchdogNone DomainEventWatchdogAction = iota + DomainEventWatchdogPause DomainEventWatchdogAction = 1 + DomainEventWatchdogReset DomainEventWatchdogAction = 2 + DomainEventWatchdogPoweroff DomainEventWatchdogAction = 3 + DomainEventWatchdogShutdown DomainEventWatchdogAction = 4 + DomainEventWatchdogDebug DomainEventWatchdogAction = 5 + DomainEventWatchdogInjectnmi DomainEventWatchdogAction = 6 +) + +// DomainEventIOErrorAction as declared in libvirt/libvirt-domain.h:3701 +type DomainEventIOErrorAction int32 + +// DomainEventIOErrorAction enumeration from libvirt/libvirt-domain.h:3701 +const ( + DomainEventIoErrorNone DomainEventIOErrorAction = iota + DomainEventIoErrorPause DomainEventIOErrorAction = 1 + DomainEventIoErrorReport DomainEventIOErrorAction = 2 +) + +// DomainEventGraphicsPhase as declared in libvirt/libvirt-domain.h:3764 +type DomainEventGraphicsPhase int32 + +// DomainEventGraphicsPhase enumeration from libvirt/libvirt-domain.h:3764 +const ( + DomainEventGraphicsConnect DomainEventGraphicsPhase = iota + DomainEventGraphicsInitialize DomainEventGraphicsPhase = 1 + DomainEventGraphicsDisconnect DomainEventGraphicsPhase = 2 +) + +// DomainEventGraphicsAddressType as declared in libvirt/libvirt-domain.h:3779 +type DomainEventGraphicsAddressType int32 + +// DomainEventGraphicsAddressType enumeration from libvirt/libvirt-domain.h:3779 +const ( + DomainEventGraphicsAddressIpv4 DomainEventGraphicsAddressType = iota + DomainEventGraphicsAddressIpv6 DomainEventGraphicsAddressType = 1 + DomainEventGraphicsAddressUnix DomainEventGraphicsAddressType = 2 +) + +// ConnectDomainEventBlockJobStatus as declared in libvirt/libvirt-domain.h:3867 +type ConnectDomainEventBlockJobStatus int32 + +// ConnectDomainEventBlockJobStatus enumeration from libvirt/libvirt-domain.h:3867 +const ( + DomainBlockJobCompleted ConnectDomainEventBlockJobStatus = iota + DomainBlockJobFailed ConnectDomainEventBlockJobStatus = 1 + DomainBlockJobCanceled ConnectDomainEventBlockJobStatus = 2 + DomainBlockJobReady ConnectDomainEventBlockJobStatus = 3 +) + +// ConnectDomainEventDiskChangeReason as declared in libvirt/libvirt-domain.h:3917 +type ConnectDomainEventDiskChangeReason int32 + +// ConnectDomainEventDiskChangeReason enumeration from libvirt/libvirt-domain.h:3917 +const ( + DomainEventDiskChangeMissingOnStart ConnectDomainEventDiskChangeReason = iota + DomainEventDiskDropMissingOnStart ConnectDomainEventDiskChangeReason = 1 +) + +// DomainEventTrayChangeReason as declared in libvirt/libvirt-domain.h:3958 +type DomainEventTrayChangeReason int32 + +// DomainEventTrayChangeReason enumeration from libvirt/libvirt-domain.h:3958 +const ( + DomainEventTrayChangeOpen DomainEventTrayChangeReason = iota + DomainEventTrayChangeClose DomainEventTrayChangeReason = 1 +) + +// ConnectDomainEventAgentLifecycleState as declared in libvirt/libvirt-domain.h:4475 +type ConnectDomainEventAgentLifecycleState int32 + +// ConnectDomainEventAgentLifecycleState enumeration from libvirt/libvirt-domain.h:4475 +const ( + ConnectDomainEventAgentLifecycleStateConnected ConnectDomainEventAgentLifecycleState = 1 + ConnectDomainEventAgentLifecycleStateDisconnected ConnectDomainEventAgentLifecycleState = 2 +) + +// ConnectDomainEventAgentLifecycleReason as declared in libvirt/libvirt-domain.h:4485 +type ConnectDomainEventAgentLifecycleReason int32 + +// ConnectDomainEventAgentLifecycleReason enumeration from libvirt/libvirt-domain.h:4485 +const ( + ConnectDomainEventAgentLifecycleReasonUnknown ConnectDomainEventAgentLifecycleReason = iota + ConnectDomainEventAgentLifecycleReasonDomainStarted ConnectDomainEventAgentLifecycleReason = 1 + ConnectDomainEventAgentLifecycleReasonChannel ConnectDomainEventAgentLifecycleReason = 2 +) + +// DomainEventID as declared in libvirt/libvirt-domain.h:4589 +type DomainEventID int32 + +// DomainEventID enumeration from libvirt/libvirt-domain.h:4589 +const ( + DomainEventIDLifecycle DomainEventID = iota + DomainEventIDReboot DomainEventID = 1 + DomainEventIDRtcChange DomainEventID = 2 + DomainEventIDWatchdog DomainEventID = 3 + DomainEventIDIoError DomainEventID = 4 + DomainEventIDGraphics DomainEventID = 5 + DomainEventIDIoErrorReason DomainEventID = 6 + DomainEventIDControlError DomainEventID = 7 + DomainEventIDBlockJob DomainEventID = 8 + DomainEventIDDiskChange DomainEventID = 9 + DomainEventIDTrayChange DomainEventID = 10 + DomainEventIDPmwakeup DomainEventID = 11 + DomainEventIDPmsuspend DomainEventID = 12 + DomainEventIDBalloonChange DomainEventID = 13 + DomainEventIDPmsuspendDisk DomainEventID = 14 + DomainEventIDDeviceRemoved DomainEventID = 15 + DomainEventIDBlockJob2 DomainEventID = 16 + DomainEventIDTunable DomainEventID = 17 + DomainEventIDAgentLifecycle DomainEventID = 18 + DomainEventIDDeviceAdded DomainEventID = 19 + DomainEventIDMigrationIteration DomainEventID = 20 + DomainEventIDJobCompleted DomainEventID = 21 + DomainEventIDDeviceRemovalFailed DomainEventID = 22 + DomainEventIDMetadataChange DomainEventID = 23 + DomainEventIDBlockThreshold DomainEventID = 24 +) + +// DomainConsoleFlags as declared in libvirt/libvirt-domain.h:4616 +type DomainConsoleFlags int32 + +// DomainConsoleFlags enumeration from libvirt/libvirt-domain.h:4616 +const ( + DomainConsoleForce DomainConsoleFlags = 1 + DomainConsoleSafe DomainConsoleFlags = 2 +) + +// DomainChannelFlags as declared in libvirt/libvirt-domain.h:4632 +type DomainChannelFlags int32 + +// DomainChannelFlags enumeration from libvirt/libvirt-domain.h:4632 +const ( + DomainChannelForce DomainChannelFlags = 1 +) + +// DomainOpenGraphicsFlags as declared in libvirt/libvirt-domain.h:4641 +type DomainOpenGraphicsFlags int32 + +// DomainOpenGraphicsFlags enumeration from libvirt/libvirt-domain.h:4641 +const ( + DomainOpenGraphicsSkipauth DomainOpenGraphicsFlags = 1 +) + +// DomainSetTimeFlags as declared in libvirt/libvirt-domain.h:4698 +type DomainSetTimeFlags int32 + +// DomainSetTimeFlags enumeration from libvirt/libvirt-domain.h:4698 +const ( + DomainTimeSync DomainSetTimeFlags = 1 +) + +// SchedParameterType as declared in libvirt/libvirt-domain.h:4719 +type SchedParameterType int32 + +// SchedParameterType enumeration from libvirt/libvirt-domain.h:4719 +const ( + DomainSchedFieldInt SchedParameterType = 1 + DomainSchedFieldUint SchedParameterType = 2 + DomainSchedFieldLlong SchedParameterType = 3 + DomainSchedFieldUllong SchedParameterType = 4 + DomainSchedFieldDouble SchedParameterType = 5 + DomainSchedFieldBoolean SchedParameterType = 6 +) + +// BlkioParameterType as declared in libvirt/libvirt-domain.h:4763 +type BlkioParameterType int32 + +// BlkioParameterType enumeration from libvirt/libvirt-domain.h:4763 +const ( + DomainBlkioParamInt BlkioParameterType = 1 + DomainBlkioParamUint BlkioParameterType = 2 + DomainBlkioParamLlong BlkioParameterType = 3 + DomainBlkioParamUllong BlkioParameterType = 4 + DomainBlkioParamDouble BlkioParameterType = 5 + DomainBlkioParamBoolean BlkioParameterType = 6 +) + +// MemoryParameterType as declared in libvirt/libvirt-domain.h:4807 +type MemoryParameterType int32 + +// MemoryParameterType enumeration from libvirt/libvirt-domain.h:4807 +const ( + DomainMemoryParamInt MemoryParameterType = 1 + DomainMemoryParamUint MemoryParameterType = 2 + DomainMemoryParamLlong MemoryParameterType = 3 + DomainMemoryParamUllong MemoryParameterType = 4 + DomainMemoryParamDouble MemoryParameterType = 5 + DomainMemoryParamBoolean MemoryParameterType = 6 +) + +// DomainInterfaceAddressesSource as declared in libvirt/libvirt-domain.h:4845 +type DomainInterfaceAddressesSource int32 + +// DomainInterfaceAddressesSource enumeration from libvirt/libvirt-domain.h:4845 +const ( + DomainInterfaceAddressesSrcLease DomainInterfaceAddressesSource = iota + DomainInterfaceAddressesSrcAgent DomainInterfaceAddressesSource = 1 + DomainInterfaceAddressesSrcArp DomainInterfaceAddressesSource = 2 +) + +// DomainSetUserPasswordFlags as declared in libvirt/libvirt-domain.h:4873 +type DomainSetUserPasswordFlags int32 + +// DomainSetUserPasswordFlags enumeration from libvirt/libvirt-domain.h:4873 +const ( + DomainPasswordEncrypted DomainSetUserPasswordFlags = 1 +) + +// DomainLifecycle as declared in libvirt/libvirt-domain.h:4912 +type DomainLifecycle int32 + +// DomainLifecycle enumeration from libvirt/libvirt-domain.h:4912 +const ( + DomainLifecyclePoweroff DomainLifecycle = iota + DomainLifecycleReboot DomainLifecycle = 1 + DomainLifecycleCrash DomainLifecycle = 2 +) + +// DomainLifecycleAction as declared in libvirt/libvirt-domain.h:4925 +type DomainLifecycleAction int32 + +// DomainLifecycleAction enumeration from libvirt/libvirt-domain.h:4925 +const ( + DomainLifecycleActionDestroy DomainLifecycleAction = iota + DomainLifecycleActionRestart DomainLifecycleAction = 1 + DomainLifecycleActionRestartRename DomainLifecycleAction = 2 + DomainLifecycleActionPreserve DomainLifecycleAction = 3 + DomainLifecycleActionCoredumpDestroy DomainLifecycleAction = 4 + DomainLifecycleActionCoredumpRestart DomainLifecycleAction = 5 +) + +// DomainGuestInfoTypes as declared in libvirt/libvirt-domain.h:4955 +type DomainGuestInfoTypes int32 + +// DomainGuestInfoTypes enumeration from libvirt/libvirt-domain.h:4955 +const ( + DomainGuestInfoUsers DomainGuestInfoTypes = 1 + DomainGuestInfoOs DomainGuestInfoTypes = 2 + DomainGuestInfoTimezone DomainGuestInfoTypes = 4 + DomainGuestInfoHostname DomainGuestInfoTypes = 8 + DomainGuestInfoFilesystem DomainGuestInfoTypes = 16 +) + +// DomainAgentResponseTimeoutValues as declared in libvirt/libvirt-domain.h:4967 +type DomainAgentResponseTimeoutValues int32 + +// DomainAgentResponseTimeoutValues enumeration from libvirt/libvirt-domain.h:4967 +const ( + DomainAgentResponseTimeoutBlock DomainAgentResponseTimeoutValues = -2 + DomainAgentResponseTimeoutDefault DomainAgentResponseTimeoutValues = -1 + DomainAgentResponseTimeoutNowait DomainAgentResponseTimeoutValues = 0 +) + +// DomainBackupBeginFlags as declared in libvirt/libvirt-domain.h:4976 +type DomainBackupBeginFlags int32 + +// DomainBackupBeginFlags enumeration from libvirt/libvirt-domain.h:4976 +const ( + DomainBackupBeginReuseExternal DomainBackupBeginFlags = 1 +) + +// DomainCheckpointCreateFlags as declared in libvirt/libvirt-domain-checkpoint.h:60 +type DomainCheckpointCreateFlags int32 + +// DomainCheckpointCreateFlags enumeration from libvirt/libvirt-domain-checkpoint.h:60 +const ( + DomainCheckpointCreateRedefine DomainCheckpointCreateFlags = 1 + DomainCheckpointCreateQuiesce DomainCheckpointCreateFlags = 2 +) + +// DomainCheckpointXMLFlags as declared in libvirt/libvirt-domain-checkpoint.h:73 +type DomainCheckpointXMLFlags int32 + +// DomainCheckpointXMLFlags enumeration from libvirt/libvirt-domain-checkpoint.h:73 +const ( + DomainCheckpointXMLSecure DomainCheckpointXMLFlags = 1 + DomainCheckpointXMLNoDomain DomainCheckpointXMLFlags = 2 + DomainCheckpointXMLSize DomainCheckpointXMLFlags = 4 +) + +// DomainCheckpointListFlags as declared in libvirt/libvirt-domain-checkpoint.h:103 +type DomainCheckpointListFlags int32 + +// DomainCheckpointListFlags enumeration from libvirt/libvirt-domain-checkpoint.h:103 +const ( + DomainCheckpointListRoots DomainCheckpointListFlags = 1 + DomainCheckpointListDescendants DomainCheckpointListFlags = 1 + DomainCheckpointListTopological DomainCheckpointListFlags = 2 + DomainCheckpointListLeaves DomainCheckpointListFlags = 4 + DomainCheckpointListNoLeaves DomainCheckpointListFlags = 8 +) + +// DomainCheckpointDeleteFlags as declared in libvirt/libvirt-domain-checkpoint.h:129 +type DomainCheckpointDeleteFlags int32 + +// DomainCheckpointDeleteFlags enumeration from libvirt/libvirt-domain-checkpoint.h:129 +const ( + DomainCheckpointDeleteChildren DomainCheckpointDeleteFlags = 1 + DomainCheckpointDeleteMetadataOnly DomainCheckpointDeleteFlags = 2 + DomainCheckpointDeleteChildrenOnly DomainCheckpointDeleteFlags = 4 +) + +// DomainSnapshotCreateFlags as declared in libvirt/libvirt-domain-snapshot.h:76 +type DomainSnapshotCreateFlags int32 + +// DomainSnapshotCreateFlags enumeration from libvirt/libvirt-domain-snapshot.h:76 +const ( + DomainSnapshotCreateRedefine DomainSnapshotCreateFlags = 1 + DomainSnapshotCreateCurrent DomainSnapshotCreateFlags = 2 + DomainSnapshotCreateNoMetadata DomainSnapshotCreateFlags = 4 + DomainSnapshotCreateHalt DomainSnapshotCreateFlags = 8 + DomainSnapshotCreateDiskOnly DomainSnapshotCreateFlags = 16 + DomainSnapshotCreateReuseExt DomainSnapshotCreateFlags = 32 + DomainSnapshotCreateQuiesce DomainSnapshotCreateFlags = 64 + DomainSnapshotCreateAtomic DomainSnapshotCreateFlags = 128 + DomainSnapshotCreateLive DomainSnapshotCreateFlags = 256 + DomainSnapshotCreateValidate DomainSnapshotCreateFlags = 512 +) + +// DomainSnapshotXMLFlags as declared in libvirt/libvirt-domain-snapshot.h:85 +type DomainSnapshotXMLFlags int32 + +// DomainSnapshotXMLFlags enumeration from libvirt/libvirt-domain-snapshot.h:85 +const ( + DomainSnapshotXMLSecure DomainSnapshotXMLFlags = 1 +) + +// DomainSnapshotListFlags as declared in libvirt/libvirt-domain-snapshot.h:144 +type DomainSnapshotListFlags int32 + +// DomainSnapshotListFlags enumeration from libvirt/libvirt-domain-snapshot.h:144 +const ( + DomainSnapshotListRoots DomainSnapshotListFlags = 1 + DomainSnapshotListDescendants DomainSnapshotListFlags = 1 + DomainSnapshotListLeaves DomainSnapshotListFlags = 4 + DomainSnapshotListNoLeaves DomainSnapshotListFlags = 8 + DomainSnapshotListMetadata DomainSnapshotListFlags = 2 + DomainSnapshotListNoMetadata DomainSnapshotListFlags = 16 + DomainSnapshotListInactive DomainSnapshotListFlags = 32 + DomainSnapshotListActive DomainSnapshotListFlags = 64 + DomainSnapshotListDiskOnly DomainSnapshotListFlags = 128 + DomainSnapshotListInternal DomainSnapshotListFlags = 256 + DomainSnapshotListExternal DomainSnapshotListFlags = 512 + DomainSnapshotListTopological DomainSnapshotListFlags = 1024 +) + +// DomainSnapshotRevertFlags as declared in libvirt/libvirt-domain-snapshot.h:201 +type DomainSnapshotRevertFlags int32 + +// DomainSnapshotRevertFlags enumeration from libvirt/libvirt-domain-snapshot.h:201 +const ( + DomainSnapshotRevertRunning DomainSnapshotRevertFlags = 1 + DomainSnapshotRevertPaused DomainSnapshotRevertFlags = 2 + DomainSnapshotRevertForce DomainSnapshotRevertFlags = 4 +) + +// DomainSnapshotDeleteFlags as declared in libvirt/libvirt-domain-snapshot.h:215 +type DomainSnapshotDeleteFlags int32 + +// DomainSnapshotDeleteFlags enumeration from libvirt/libvirt-domain-snapshot.h:215 +const ( + DomainSnapshotDeleteChildren DomainSnapshotDeleteFlags = 1 + DomainSnapshotDeleteMetadataOnly DomainSnapshotDeleteFlags = 2 + DomainSnapshotDeleteChildrenOnly DomainSnapshotDeleteFlags = 4 +) + +// EventHandleType as declared in libvirt/libvirt-event.h:43 +type EventHandleType int32 + +// EventHandleType enumeration from libvirt/libvirt-event.h:43 +const ( + EventHandleReadable EventHandleType = 1 + EventHandleWritable EventHandleType = 2 + EventHandleError EventHandleType = 4 + EventHandleHangup EventHandleType = 8 +) + +// ConnectListAllInterfacesFlags as declared in libvirt/libvirt-interface.h:64 +type ConnectListAllInterfacesFlags int32 + +// ConnectListAllInterfacesFlags enumeration from libvirt/libvirt-interface.h:64 +const ( + ConnectListInterfacesInactive ConnectListAllInterfacesFlags = 1 + ConnectListInterfacesActive ConnectListAllInterfacesFlags = 2 +) + +// InterfaceXMLFlags as declared in libvirt/libvirt-interface.h:80 +type InterfaceXMLFlags int32 + +// InterfaceXMLFlags enumeration from libvirt/libvirt-interface.h:80 +const ( + InterfaceXMLInactive InterfaceXMLFlags = 1 +) + +// NetworkXMLFlags as declared in libvirt/libvirt-network.h:32 +type NetworkXMLFlags int32 + +// NetworkXMLFlags enumeration from libvirt/libvirt-network.h:32 +const ( + NetworkXMLInactive NetworkXMLFlags = 1 +) + +// ConnectListAllNetworksFlags as declared in libvirt/libvirt-network.h:100 +type ConnectListAllNetworksFlags int32 + +// ConnectListAllNetworksFlags enumeration from libvirt/libvirt-network.h:100 +const ( + ConnectListNetworksInactive ConnectListAllNetworksFlags = 1 + ConnectListNetworksActive ConnectListAllNetworksFlags = 2 + ConnectListNetworksPersistent ConnectListAllNetworksFlags = 4 + ConnectListNetworksTransient ConnectListAllNetworksFlags = 8 + ConnectListNetworksAutostart ConnectListAllNetworksFlags = 16 + ConnectListNetworksNoAutostart ConnectListAllNetworksFlags = 32 +) + +// NetworkUpdateCommand as declared in libvirt/libvirt-network.h:149 +type NetworkUpdateCommand int32 + +// NetworkUpdateCommand enumeration from libvirt/libvirt-network.h:149 +const ( + NetworkUpdateCommandNone NetworkUpdateCommand = iota + NetworkUpdateCommandModify NetworkUpdateCommand = 1 + NetworkUpdateCommandDelete NetworkUpdateCommand = 2 + NetworkUpdateCommandAddLast NetworkUpdateCommand = 3 + NetworkUpdateCommandAddFirst NetworkUpdateCommand = 4 +) + +// NetworkUpdateSection as declared in libvirt/libvirt-network.h:175 +type NetworkUpdateSection int32 + +// NetworkUpdateSection enumeration from libvirt/libvirt-network.h:175 +const ( + NetworkSectionNone NetworkUpdateSection = iota + NetworkSectionBridge NetworkUpdateSection = 1 + NetworkSectionDomain NetworkUpdateSection = 2 + NetworkSectionIP NetworkUpdateSection = 3 + NetworkSectionIPDhcpHost NetworkUpdateSection = 4 + NetworkSectionIPDhcpRange NetworkUpdateSection = 5 + NetworkSectionForward NetworkUpdateSection = 6 + NetworkSectionForwardInterface NetworkUpdateSection = 7 + NetworkSectionForwardPf NetworkUpdateSection = 8 + NetworkSectionPortgroup NetworkUpdateSection = 9 + NetworkSectionDNSHost NetworkUpdateSection = 10 + NetworkSectionDNSTxt NetworkUpdateSection = 11 + NetworkSectionDNSSrv NetworkUpdateSection = 12 +) + +// NetworkUpdateFlags as declared in libvirt/libvirt-network.h:187 +type NetworkUpdateFlags int32 + +// NetworkUpdateFlags enumeration from libvirt/libvirt-network.h:187 +const ( + NetworkUpdateAffectCurrent NetworkUpdateFlags = iota + NetworkUpdateAffectLive NetworkUpdateFlags = 1 + NetworkUpdateAffectConfig NetworkUpdateFlags = 2 +) + +// NetworkEventLifecycleType as declared in libvirt/libvirt-network.h:245 +type NetworkEventLifecycleType int32 + +// NetworkEventLifecycleType enumeration from libvirt/libvirt-network.h:245 +const ( + NetworkEventDefined NetworkEventLifecycleType = iota + NetworkEventUndefined NetworkEventLifecycleType = 1 + NetworkEventStarted NetworkEventLifecycleType = 2 + NetworkEventStopped NetworkEventLifecycleType = 3 +) + +// NetworkEventID as declared in libvirt/libvirt-network.h:293 +type NetworkEventID int32 + +// NetworkEventID enumeration from libvirt/libvirt-network.h:293 +const ( + NetworkEventIDLifecycle NetworkEventID = iota +) + +// IPAddrType as declared in libvirt/libvirt-network.h:302 +type IPAddrType int32 + +// IPAddrType enumeration from libvirt/libvirt-network.h:302 +const ( + IPAddrTypeIpv4 IPAddrType = iota + IPAddrTypeIpv6 IPAddrType = 1 +) + +// NetworkPortCreateFlags as declared in libvirt/libvirt-network.h:363 +type NetworkPortCreateFlags int32 + +// NetworkPortCreateFlags enumeration from libvirt/libvirt-network.h:363 +const ( + NetworkPortCreateReclaim NetworkPortCreateFlags = 1 +) + +// ConnectListAllNodeDeviceFlags as declared in libvirt/libvirt-nodedev.h:84 +type ConnectListAllNodeDeviceFlags int32 + +// ConnectListAllNodeDeviceFlags enumeration from libvirt/libvirt-nodedev.h:84 +const ( + ConnectListNodeDevicesCapSystem ConnectListAllNodeDeviceFlags = 1 + ConnectListNodeDevicesCapPciDev ConnectListAllNodeDeviceFlags = 2 + ConnectListNodeDevicesCapUsbDev ConnectListAllNodeDeviceFlags = 4 + ConnectListNodeDevicesCapUsbInterface ConnectListAllNodeDeviceFlags = 8 + ConnectListNodeDevicesCapNet ConnectListAllNodeDeviceFlags = 16 + ConnectListNodeDevicesCapScsiHost ConnectListAllNodeDeviceFlags = 32 + ConnectListNodeDevicesCapScsiTarget ConnectListAllNodeDeviceFlags = 64 + ConnectListNodeDevicesCapScsi ConnectListAllNodeDeviceFlags = 128 + ConnectListNodeDevicesCapStorage ConnectListAllNodeDeviceFlags = 256 + ConnectListNodeDevicesCapFcHost ConnectListAllNodeDeviceFlags = 512 + ConnectListNodeDevicesCapVports ConnectListAllNodeDeviceFlags = 1024 + ConnectListNodeDevicesCapScsiGeneric ConnectListAllNodeDeviceFlags = 2048 + ConnectListNodeDevicesCapDrm ConnectListAllNodeDeviceFlags = 4096 + ConnectListNodeDevicesCapMdevTypes ConnectListAllNodeDeviceFlags = 8192 + ConnectListNodeDevicesCapMdev ConnectListAllNodeDeviceFlags = 16384 + ConnectListNodeDevicesCapCcwDev ConnectListAllNodeDeviceFlags = 32768 +) + +// NodeDeviceEventID as declared in libvirt/libvirt-nodedev.h:154 +type NodeDeviceEventID int32 + +// NodeDeviceEventID enumeration from libvirt/libvirt-nodedev.h:154 +const ( + NodeDeviceEventIDLifecycle NodeDeviceEventID = iota + NodeDeviceEventIDUpdate NodeDeviceEventID = 1 +) + +// NodeDeviceEventLifecycleType as declared in libvirt/libvirt-nodedev.h:196 +type NodeDeviceEventLifecycleType int32 + +// NodeDeviceEventLifecycleType enumeration from libvirt/libvirt-nodedev.h:196 +const ( + NodeDeviceEventCreated NodeDeviceEventLifecycleType = iota + NodeDeviceEventDeleted NodeDeviceEventLifecycleType = 1 +) + +// SecretUsageType as declared in libvirt/libvirt-secret.h:56 +type SecretUsageType int32 + +// SecretUsageType enumeration from libvirt/libvirt-secret.h:56 +const ( + SecretUsageTypeNone SecretUsageType = iota + SecretUsageTypeVolume SecretUsageType = 1 + SecretUsageTypeCeph SecretUsageType = 2 + SecretUsageTypeIscsi SecretUsageType = 3 + SecretUsageTypeTLS SecretUsageType = 4 + SecretUsageTypeVtpm SecretUsageType = 5 +) + +// ConnectListAllSecretsFlags as declared in libvirt/libvirt-secret.h:79 +type ConnectListAllSecretsFlags int32 + +// ConnectListAllSecretsFlags enumeration from libvirt/libvirt-secret.h:79 +const ( + ConnectListSecretsEphemeral ConnectListAllSecretsFlags = 1 + ConnectListSecretsNoEphemeral ConnectListAllSecretsFlags = 2 + ConnectListSecretsPrivate ConnectListAllSecretsFlags = 4 + ConnectListSecretsNoPrivate ConnectListAllSecretsFlags = 8 +) + +// SecretEventID as declared in libvirt/libvirt-secret.h:140 +type SecretEventID int32 + +// SecretEventID enumeration from libvirt/libvirt-secret.h:140 +const ( + SecretEventIDLifecycle SecretEventID = iota + SecretEventIDValueChanged SecretEventID = 1 +) + +// SecretEventLifecycleType as declared in libvirt/libvirt-secret.h:182 +type SecretEventLifecycleType int32 + +// SecretEventLifecycleType enumeration from libvirt/libvirt-secret.h:182 +const ( + SecretEventDefined SecretEventLifecycleType = iota + SecretEventUndefined SecretEventLifecycleType = 1 +) + +// StoragePoolState as declared in libvirt/libvirt-storage.h:57 +type StoragePoolState int32 + +// StoragePoolState enumeration from libvirt/libvirt-storage.h:57 +const ( + StoragePoolInactive StoragePoolState = iota + StoragePoolBuilding StoragePoolState = 1 + StoragePoolRunning StoragePoolState = 2 + StoragePoolDegraded StoragePoolState = 3 + StoragePoolInaccessible StoragePoolState = 4 +) + +// StoragePoolBuildFlags as declared in libvirt/libvirt-storage.h:65 +type StoragePoolBuildFlags int32 + +// StoragePoolBuildFlags enumeration from libvirt/libvirt-storage.h:65 +const ( + StoragePoolBuildNew StoragePoolBuildFlags = iota + StoragePoolBuildRepair StoragePoolBuildFlags = 1 + StoragePoolBuildResize StoragePoolBuildFlags = 2 + StoragePoolBuildNoOverwrite StoragePoolBuildFlags = 4 + StoragePoolBuildOverwrite StoragePoolBuildFlags = 8 +) + +// StoragePoolDeleteFlags as declared in libvirt/libvirt-storage.h:70 +type StoragePoolDeleteFlags int32 + +// StoragePoolDeleteFlags enumeration from libvirt/libvirt-storage.h:70 +const ( + StoragePoolDeleteNormal StoragePoolDeleteFlags = iota + StoragePoolDeleteZeroed StoragePoolDeleteFlags = 1 +) + +// StoragePoolCreateFlags as declared in libvirt/libvirt-storage.h:87 +type StoragePoolCreateFlags int32 + +// StoragePoolCreateFlags enumeration from libvirt/libvirt-storage.h:87 +const ( + StoragePoolCreateNormal StoragePoolCreateFlags = iota + StoragePoolCreateWithBuild StoragePoolCreateFlags = 1 + StoragePoolCreateWithBuildOverwrite StoragePoolCreateFlags = 2 + StoragePoolCreateWithBuildNoOverwrite StoragePoolCreateFlags = 4 +) + +// StorageVolType as declared in libvirt/libvirt-storage.h:129 +type StorageVolType int32 + +// StorageVolType enumeration from libvirt/libvirt-storage.h:129 +const ( + StorageVolFile StorageVolType = iota + StorageVolBlock StorageVolType = 1 + StorageVolDir StorageVolType = 2 + StorageVolNetwork StorageVolType = 3 + StorageVolNetdir StorageVolType = 4 + StorageVolPloop StorageVolType = 5 +) + +// StorageVolDeleteFlags as declared in libvirt/libvirt-storage.h:135 +type StorageVolDeleteFlags int32 + +// StorageVolDeleteFlags enumeration from libvirt/libvirt-storage.h:135 +const ( + StorageVolDeleteNormal StorageVolDeleteFlags = iota + StorageVolDeleteZeroed StorageVolDeleteFlags = 1 + StorageVolDeleteWithSnapshots StorageVolDeleteFlags = 2 +) + +// StorageVolWipeAlgorithm as declared in libvirt/libvirt-storage.h:167 +type StorageVolWipeAlgorithm int32 + +// StorageVolWipeAlgorithm enumeration from libvirt/libvirt-storage.h:167 +const ( + StorageVolWipeAlgZero StorageVolWipeAlgorithm = iota + StorageVolWipeAlgNnsa StorageVolWipeAlgorithm = 1 + StorageVolWipeAlgDod StorageVolWipeAlgorithm = 2 + StorageVolWipeAlgBsi StorageVolWipeAlgorithm = 3 + StorageVolWipeAlgGutmann StorageVolWipeAlgorithm = 4 + StorageVolWipeAlgSchneier StorageVolWipeAlgorithm = 5 + StorageVolWipeAlgPfitzner7 StorageVolWipeAlgorithm = 6 + StorageVolWipeAlgPfitzner33 StorageVolWipeAlgorithm = 7 + StorageVolWipeAlgRandom StorageVolWipeAlgorithm = 8 + StorageVolWipeAlgTrim StorageVolWipeAlgorithm = 9 +) + +// StorageVolInfoFlags as declared in libvirt/libvirt-storage.h:175 +type StorageVolInfoFlags int32 + +// StorageVolInfoFlags enumeration from libvirt/libvirt-storage.h:175 +const ( + StorageVolUseAllocation StorageVolInfoFlags = iota + StorageVolGetPhysical StorageVolInfoFlags = 1 +) + +// StorageXMLFlags as declared in libvirt/libvirt-storage.h:189 +type StorageXMLFlags int32 + +// StorageXMLFlags enumeration from libvirt/libvirt-storage.h:189 +const ( + StorageXMLInactive StorageXMLFlags = 1 +) + +// ConnectListAllStoragePoolsFlags as declared in libvirt/libvirt-storage.h:248 +type ConnectListAllStoragePoolsFlags int32 + +// ConnectListAllStoragePoolsFlags enumeration from libvirt/libvirt-storage.h:248 +const ( + ConnectListStoragePoolsInactive ConnectListAllStoragePoolsFlags = 1 + ConnectListStoragePoolsActive ConnectListAllStoragePoolsFlags = 2 + ConnectListStoragePoolsPersistent ConnectListAllStoragePoolsFlags = 4 + ConnectListStoragePoolsTransient ConnectListAllStoragePoolsFlags = 8 + ConnectListStoragePoolsAutostart ConnectListAllStoragePoolsFlags = 16 + ConnectListStoragePoolsNoAutostart ConnectListAllStoragePoolsFlags = 32 + ConnectListStoragePoolsDir ConnectListAllStoragePoolsFlags = 64 + ConnectListStoragePoolsFs ConnectListAllStoragePoolsFlags = 128 + ConnectListStoragePoolsNetfs ConnectListAllStoragePoolsFlags = 256 + ConnectListStoragePoolsLogical ConnectListAllStoragePoolsFlags = 512 + ConnectListStoragePoolsDisk ConnectListAllStoragePoolsFlags = 1024 + ConnectListStoragePoolsIscsi ConnectListAllStoragePoolsFlags = 2048 + ConnectListStoragePoolsScsi ConnectListAllStoragePoolsFlags = 4096 + ConnectListStoragePoolsMpath ConnectListAllStoragePoolsFlags = 8192 + ConnectListStoragePoolsRbd ConnectListAllStoragePoolsFlags = 16384 + ConnectListStoragePoolsSheepdog ConnectListAllStoragePoolsFlags = 32768 + ConnectListStoragePoolsGluster ConnectListAllStoragePoolsFlags = 65536 + ConnectListStoragePoolsZfs ConnectListAllStoragePoolsFlags = 131072 + ConnectListStoragePoolsVstorage ConnectListAllStoragePoolsFlags = 262144 + ConnectListStoragePoolsIscsiDirect ConnectListAllStoragePoolsFlags = 524288 +) + +// StorageVolCreateFlags as declared in libvirt/libvirt-storage.h:346 +type StorageVolCreateFlags int32 + +// StorageVolCreateFlags enumeration from libvirt/libvirt-storage.h:346 +const ( + StorageVolCreatePreallocMetadata StorageVolCreateFlags = 1 + StorageVolCreateReflink StorageVolCreateFlags = 2 +) + +// StorageVolDownloadFlags as declared in libvirt/libvirt-storage.h:358 +type StorageVolDownloadFlags int32 + +// StorageVolDownloadFlags enumeration from libvirt/libvirt-storage.h:358 +const ( + StorageVolDownloadSparseStream StorageVolDownloadFlags = 1 +) + +// StorageVolUploadFlags as declared in libvirt/libvirt-storage.h:367 +type StorageVolUploadFlags int32 + +// StorageVolUploadFlags enumeration from libvirt/libvirt-storage.h:367 +const ( + StorageVolUploadSparseStream StorageVolUploadFlags = 1 +) + +// StorageVolResizeFlags as declared in libvirt/libvirt-storage.h:398 +type StorageVolResizeFlags int32 + +// StorageVolResizeFlags enumeration from libvirt/libvirt-storage.h:398 +const ( + StorageVolResizeAllocate StorageVolResizeFlags = 1 + StorageVolResizeDelta StorageVolResizeFlags = 2 + StorageVolResizeShrink StorageVolResizeFlags = 4 +) + +// StoragePoolEventID as declared in libvirt/libvirt-storage.h:434 +type StoragePoolEventID int32 + +// StoragePoolEventID enumeration from libvirt/libvirt-storage.h:434 +const ( + StoragePoolEventIDLifecycle StoragePoolEventID = iota + StoragePoolEventIDRefresh StoragePoolEventID = 1 +) + +// StoragePoolEventLifecycleType as declared in libvirt/libvirt-storage.h:480 +type StoragePoolEventLifecycleType int32 + +// StoragePoolEventLifecycleType enumeration from libvirt/libvirt-storage.h:480 +const ( + StoragePoolEventDefined StoragePoolEventLifecycleType = iota + StoragePoolEventUndefined StoragePoolEventLifecycleType = 1 + StoragePoolEventStarted StoragePoolEventLifecycleType = 2 + StoragePoolEventStopped StoragePoolEventLifecycleType = 3 + StoragePoolEventCreated StoragePoolEventLifecycleType = 4 + StoragePoolEventDeleted StoragePoolEventLifecycleType = 5 +) + +// StreamFlags as declared in libvirt/libvirt-stream.h:33 +type StreamFlags int32 + +// StreamFlags enumeration from libvirt/libvirt-stream.h:33 +const ( + StreamNonblock StreamFlags = 1 +) + +// StreamRecvFlagsValues as declared in libvirt/libvirt-stream.h:49 +type StreamRecvFlagsValues int32 + +// StreamRecvFlagsValues enumeration from libvirt/libvirt-stream.h:49 +const ( + StreamRecvStopAtHole StreamRecvFlagsValues = 1 +) + +// StreamEventType as declared in libvirt/libvirt-stream.h:237 +type StreamEventType int32 + +// StreamEventType enumeration from libvirt/libvirt-stream.h:237 +const ( + StreamEventReadable StreamEventType = 1 + StreamEventWritable StreamEventType = 2 + StreamEventError StreamEventType = 4 + StreamEventHangup StreamEventType = 8 +) + +// errorLevel as declared in libvirt/virterror.h:42 +type errorLevel int32 + +// errorLevel enumeration from libvirt/virterror.h:42 +const ( + errNone errorLevel = iota + errWarning errorLevel = 1 + errError errorLevel = 2 +) + +// errorDomain as declared in libvirt/virterror.h:143 +type errorDomain int32 + +// errorDomain enumeration from libvirt/virterror.h:143 +const ( + fromNone errorDomain = iota + fromXen errorDomain = 1 + fromXend errorDomain = 2 + fromXenstore errorDomain = 3 + fromSexpr errorDomain = 4 + fromXML errorDomain = 5 + fromDom errorDomain = 6 + fromRPC errorDomain = 7 + fromProxy errorDomain = 8 + fromConf errorDomain = 9 + fromQemu errorDomain = 10 + fromNet errorDomain = 11 + fromTest errorDomain = 12 + fromRemote errorDomain = 13 + fromOpenvz errorDomain = 14 + fromXenxm errorDomain = 15 + fromStatsLinux errorDomain = 16 + fromLxc errorDomain = 17 + fromStorage errorDomain = 18 + fromNetwork errorDomain = 19 + fromDomain errorDomain = 20 + fromUml errorDomain = 21 + fromNodedev errorDomain = 22 + fromXenInotify errorDomain = 23 + fromSecurity errorDomain = 24 + fromVbox errorDomain = 25 + fromInterface errorDomain = 26 + fromOne errorDomain = 27 + fromEsx errorDomain = 28 + fromPhyp errorDomain = 29 + fromSecret errorDomain = 30 + fromCPU errorDomain = 31 + fromXenapi errorDomain = 32 + fromNwfilter errorDomain = 33 + fromHook errorDomain = 34 + fromDomainSnapshot errorDomain = 35 + fromAudit errorDomain = 36 + fromSysinfo errorDomain = 37 + fromStreams errorDomain = 38 + fromVmware errorDomain = 39 + fromEvent errorDomain = 40 + fromLibxl errorDomain = 41 + fromLocking errorDomain = 42 + fromHyperv errorDomain = 43 + fromCapabilities errorDomain = 44 + fromURI errorDomain = 45 + fromAuth errorDomain = 46 + fromDbus errorDomain = 47 + fromParallels errorDomain = 48 + fromDevice errorDomain = 49 + fromSSH errorDomain = 50 + fromLockspace errorDomain = 51 + fromInitctl errorDomain = 52 + fromIdentity errorDomain = 53 + fromCgroup errorDomain = 54 + fromAccess errorDomain = 55 + fromSystemd errorDomain = 56 + fromBhyve errorDomain = 57 + fromCrypto errorDomain = 58 + fromFirewall errorDomain = 59 + fromPolkit errorDomain = 60 + fromThread errorDomain = 61 + fromAdmin errorDomain = 62 + fromLogging errorDomain = 63 + fromXenxl errorDomain = 64 + fromPerf errorDomain = 65 + fromLibssh errorDomain = 66 + fromResctrl errorDomain = 67 + fromFirewalld errorDomain = 68 + fromDomainCheckpoint errorDomain = 69 + fromTpm errorDomain = 70 + fromBpf errorDomain = 71 +) + +// errorNumber as declared in libvirt/virterror.h:340 +type errorNumber int32 + +// errorNumber enumeration from libvirt/virterror.h:340 +const ( + errOk errorNumber = iota + errInternalError errorNumber = 1 + errNoMemory errorNumber = 2 + errNoSupport errorNumber = 3 + errUnknownHost errorNumber = 4 + errNoConnect errorNumber = 5 + errInvalidConn errorNumber = 6 + errInvalidDomain errorNumber = 7 + errInvalidArg errorNumber = 8 + errOperationFailed errorNumber = 9 + errGetFailed errorNumber = 10 + errPostFailed errorNumber = 11 + errHTTPError errorNumber = 12 + errSexprSerial errorNumber = 13 + errNoXen errorNumber = 14 + errXenCall errorNumber = 15 + errOsType errorNumber = 16 + errNoKernel errorNumber = 17 + errNoRoot errorNumber = 18 + errNoSource errorNumber = 19 + errNoTarget errorNumber = 20 + errNoName errorNumber = 21 + errNoOs errorNumber = 22 + errNoDevice errorNumber = 23 + errNoXenstore errorNumber = 24 + errDriverFull errorNumber = 25 + errCallFailed errorNumber = 26 + errXMLError errorNumber = 27 + errDomExist errorNumber = 28 + errOperationDenied errorNumber = 29 + errOpenFailed errorNumber = 30 + errReadFailed errorNumber = 31 + errParseFailed errorNumber = 32 + errConfSyntax errorNumber = 33 + errWriteFailed errorNumber = 34 + errXMLDetail errorNumber = 35 + errInvalidNetwork errorNumber = 36 + errNetworkExist errorNumber = 37 + errSystemError errorNumber = 38 + errRPC errorNumber = 39 + errGnutlsError errorNumber = 40 + warNoNetwork errorNumber = 41 + errNoDomain errorNumber = 42 + errNoNetwork errorNumber = 43 + errInvalidMac errorNumber = 44 + errAuthFailed errorNumber = 45 + errInvalidStoragePool errorNumber = 46 + errInvalidStorageVol errorNumber = 47 + warNoStorage errorNumber = 48 + errNoStoragePool errorNumber = 49 + errNoStorageVol errorNumber = 50 + warNoNode errorNumber = 51 + errInvalidNodeDevice errorNumber = 52 + errNoNodeDevice errorNumber = 53 + errNoSecurityModel errorNumber = 54 + errOperationInvalid errorNumber = 55 + warNoInterface errorNumber = 56 + errNoInterface errorNumber = 57 + errInvalidInterface errorNumber = 58 + errMultipleInterfaces errorNumber = 59 + warNoNwfilter errorNumber = 60 + errInvalidNwfilter errorNumber = 61 + errNoNwfilter errorNumber = 62 + errBuildFirewall errorNumber = 63 + warNoSecret errorNumber = 64 + errInvalidSecret errorNumber = 65 + errNoSecret errorNumber = 66 + errConfigUnsupported errorNumber = 67 + errOperationTimeout errorNumber = 68 + errMigratePersistFailed errorNumber = 69 + errHookScriptFailed errorNumber = 70 + errInvalidDomainSnapshot errorNumber = 71 + errNoDomainSnapshot errorNumber = 72 + errInvalidStream errorNumber = 73 + errArgumentUnsupported errorNumber = 74 + errStorageProbeFailed errorNumber = 75 + errStoragePoolBuilt errorNumber = 76 + errSnapshotRevertRisky errorNumber = 77 + errOperationAborted errorNumber = 78 + errAuthCancelled errorNumber = 79 + errNoDomainMetadata errorNumber = 80 + errMigrateUnsafe errorNumber = 81 + errOverflow errorNumber = 82 + errBlockCopyActive errorNumber = 83 + errOperationUnsupported errorNumber = 84 + errSSH errorNumber = 85 + errAgentUnresponsive errorNumber = 86 + errResourceBusy errorNumber = 87 + errAccessDenied errorNumber = 88 + errDbusService errorNumber = 89 + errStorageVolExist errorNumber = 90 + errCPUIncompatible errorNumber = 91 + errXMLInvalidSchema errorNumber = 92 + errMigrateFinishOk errorNumber = 93 + errAuthUnavailable errorNumber = 94 + errNoServer errorNumber = 95 + errNoClient errorNumber = 96 + errAgentUnsynced errorNumber = 97 + errLibssh errorNumber = 98 + errDeviceMissing errorNumber = 99 + errInvalidNwfilterBinding errorNumber = 100 + errNoNwfilterBinding errorNumber = 101 + errInvalidDomainCheckpoint errorNumber = 102 + errNoDomainCheckpoint errorNumber = 103 + errNoDomainBackup errorNumber = 104 + errInvalidNetworkPort errorNumber = 105 + errNetworkPortExist errorNumber = 106 + errNoNetworkPort errorNumber = 107 + errNoHostname errorNumber = 108 + errCheckpointInconsistent errorNumber = 109 +) diff --git a/vendor/github.com/digitalocean/go-libvirt/doc.go b/vendor/github.com/digitalocean/go-libvirt/doc.go new file mode 100644 index 000000000..1229f30c8 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/doc.go @@ -0,0 +1,76 @@ +// Copyright 2016 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Package libvirt provides a pure Go interface for Libvirt. + + Rather than using Libvirt's C bindings, this package makes use of + Libvirt's RPC interface, as documented here: https://libvirt.org/internals/rpc.html. + Connections to the libvirt server may be local, or remote. RPC packets are encoded + using the XDR standard as defined by RFC 4506. + + This should be considered a work in progress. Most functionaly provided by the C + bindings have not yet made their way into this library. Pull requests are welcome! + The definition of the RPC protocol is in the libvirt source tree under src/rpc/virnetprotocol.x. + + Example usage: + + package main + + import ( + "fmt" + "log" + "net" + "time" + + "github.com/digitalocean/go-libvirt" + ) + + func main() { + //c, err := net.DialTimeout("tcp", "127.0.0.1:16509", 2*time.Second) + //c, err := net.DialTimeout("tcp", "192.168.1.12:16509", 2*time.Second) + c, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second) + if err != nil { + log.Fatalf("failed to dial libvirt: %v", err) + } + + l := libvirt.New(c) + if err := l.Connect(); err != nil { + log.Fatalf("failed to connect: %v", err) + } + + v, err := l.Version() + if err != nil { + log.Fatalf("failed to retrieve libvirt version: %v", err) + } + fmt.Println("Version:", v) + + domains, err := l.Domains() + if err != nil { + log.Fatalf("failed to retrieve domains: %v", err) + } + + fmt.Println("ID\tName\t\tUUID") + fmt.Printf("--------------------------------------------------------\n") + for _, d := range domains { + fmt.Printf("%d\t%s\t%x\n", d.ID, d.Name, d.UUID) + } + + if err := l.Disconnect(); err != nil { + log.Fatal("failed to disconnect: %v", err) + } + } +*/ + +package libvirt diff --git a/vendor/github.com/digitalocean/go-libvirt/go.mod b/vendor/github.com/digitalocean/go-libvirt/go.mod new file mode 100644 index 000000000..b0957576a --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/go.mod @@ -0,0 +1,9 @@ +module github.com/digitalocean/go-libvirt + +go 1.14 + +require ( + github.com/stretchr/testify v1.6.1 + golang.org/x/net v0.0.0-20200625001655-4c5254603344 + golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d +) diff --git a/vendor/github.com/digitalocean/go-libvirt/go.sum b/vendor/github.com/digitalocean/go-libvirt/go.sum new file mode 100644 index 000000000..a213b4803 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/go.sum @@ -0,0 +1,35 @@ +github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4= +golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200625001655-4c5254603344 h1:vGXIOMxbNfDTk/aXCmfdLgkrSV+Z2tcbze+pEc3v5W4= +golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d h1:F3OmlXCzYtG9YE6tXDnUOlJBzVzHF8EcmZ1yTJlcgIk= +golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go new file mode 100644 index 000000000..208986dee --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/constants/qemu_protocol.gen.go @@ -0,0 +1,47 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +// Code generated by internal/lvgen/generate.go. DO NOT EDIT. +// +// To regenerate, run 'go generate' in internal/lvgen. +// + +package constants + +// These are libvirt procedure numbers which correspond to each respective +// API call between remote_internal driver and libvirtd. Each procedure is +// identified by a unique number. +const ( + // From enums: + // QEMUProcDomainMonitorCommand is libvirt's QEMU_PROC_DOMAIN_MONITOR_COMMAND + QEMUProcDomainMonitorCommand = 1 + // QEMUProcDomainAttach is libvirt's QEMU_PROC_DOMAIN_ATTACH + QEMUProcDomainAttach = 2 + // QEMUProcDomainAgentCommand is libvirt's QEMU_PROC_DOMAIN_AGENT_COMMAND + QEMUProcDomainAgentCommand = 3 + // QEMUProcConnectDomainMonitorEventRegister is libvirt's QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER + QEMUProcConnectDomainMonitorEventRegister = 4 + // QEMUProcConnectDomainMonitorEventDeregister is libvirt's QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER + QEMUProcConnectDomainMonitorEventDeregister = 5 + // QEMUProcDomainMonitorEvent is libvirt's QEMU_PROC_DOMAIN_MONITOR_EVENT + QEMUProcDomainMonitorEvent = 6 + + + // From consts: + // QEMUProgram is libvirt's QEMU_PROGRAM + QEMUProgram = 0x20008087 + // QEMUProtocolVersion is libvirt's QEMU_PROTOCOL_VERSION + QEMUProtocolVersion = 1 +) diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go new file mode 100644 index 000000000..9b9601cb9 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/constants/remote_protocol.gen.go @@ -0,0 +1,1019 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +// Code generated by internal/lvgen/generate.go. DO NOT EDIT. +// +// To regenerate, run 'go generate' in internal/lvgen. +// + +package constants + +// These are libvirt procedure numbers which correspond to each respective +// API call between remote_internal driver and libvirtd. Each procedure is +// identified by a unique number. +const ( + // From enums: + // AuthNone is libvirt's REMOTE_AUTH_NONE + AuthNone = 0 + // AuthSasl is libvirt's REMOTE_AUTH_SASL + AuthSasl = 1 + // AuthPolkit is libvirt's REMOTE_AUTH_POLKIT + AuthPolkit = 2 + // ProcConnectOpen is libvirt's REMOTE_PROC_CONNECT_OPEN + ProcConnectOpen = 1 + // ProcConnectClose is libvirt's REMOTE_PROC_CONNECT_CLOSE + ProcConnectClose = 2 + // ProcConnectGetType is libvirt's REMOTE_PROC_CONNECT_GET_TYPE + ProcConnectGetType = 3 + // ProcConnectGetVersion is libvirt's REMOTE_PROC_CONNECT_GET_VERSION + ProcConnectGetVersion = 4 + // ProcConnectGetMaxVcpus is libvirt's REMOTE_PROC_CONNECT_GET_MAX_VCPUS + ProcConnectGetMaxVcpus = 5 + // ProcNodeGetInfo is libvirt's REMOTE_PROC_NODE_GET_INFO + ProcNodeGetInfo = 6 + // ProcConnectGetCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_CAPABILITIES + ProcConnectGetCapabilities = 7 + // ProcDomainAttachDevice is libvirt's REMOTE_PROC_DOMAIN_ATTACH_DEVICE + ProcDomainAttachDevice = 8 + // ProcDomainCreate is libvirt's REMOTE_PROC_DOMAIN_CREATE + ProcDomainCreate = 9 + // ProcDomainCreateXML is libvirt's REMOTE_PROC_DOMAIN_CREATE_XML + ProcDomainCreateXML = 10 + // ProcDomainDefineXML is libvirt's REMOTE_PROC_DOMAIN_DEFINE_XML + ProcDomainDefineXML = 11 + // ProcDomainDestroy is libvirt's REMOTE_PROC_DOMAIN_DESTROY + ProcDomainDestroy = 12 + // ProcDomainDetachDevice is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE + ProcDomainDetachDevice = 13 + // ProcDomainGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_GET_XML_DESC + ProcDomainGetXMLDesc = 14 + // ProcDomainGetAutostart is libvirt's REMOTE_PROC_DOMAIN_GET_AUTOSTART + ProcDomainGetAutostart = 15 + // ProcDomainGetInfo is libvirt's REMOTE_PROC_DOMAIN_GET_INFO + ProcDomainGetInfo = 16 + // ProcDomainGetMaxMemory is libvirt's REMOTE_PROC_DOMAIN_GET_MAX_MEMORY + ProcDomainGetMaxMemory = 17 + // ProcDomainGetMaxVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_MAX_VCPUS + ProcDomainGetMaxVcpus = 18 + // ProcDomainGetOsType is libvirt's REMOTE_PROC_DOMAIN_GET_OS_TYPE + ProcDomainGetOsType = 19 + // ProcDomainGetVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_VCPUS + ProcDomainGetVcpus = 20 + // ProcConnectListDefinedDomains is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_DOMAINS + ProcConnectListDefinedDomains = 21 + // ProcDomainLookupByID is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_ID + ProcDomainLookupByID = 22 + // ProcDomainLookupByName is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME + ProcDomainLookupByName = 23 + // ProcDomainLookupByUUID is libvirt's REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID + ProcDomainLookupByUUID = 24 + // ProcConnectNumOfDefinedDomains is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_DOMAINS + ProcConnectNumOfDefinedDomains = 25 + // ProcDomainPinVcpu is libvirt's REMOTE_PROC_DOMAIN_PIN_VCPU + ProcDomainPinVcpu = 26 + // ProcDomainReboot is libvirt's REMOTE_PROC_DOMAIN_REBOOT + ProcDomainReboot = 27 + // ProcDomainResume is libvirt's REMOTE_PROC_DOMAIN_RESUME + ProcDomainResume = 28 + // ProcDomainSetAutostart is libvirt's REMOTE_PROC_DOMAIN_SET_AUTOSTART + ProcDomainSetAutostart = 29 + // ProcDomainSetMaxMemory is libvirt's REMOTE_PROC_DOMAIN_SET_MAX_MEMORY + ProcDomainSetMaxMemory = 30 + // ProcDomainSetMemory is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY + ProcDomainSetMemory = 31 + // ProcDomainSetVcpus is libvirt's REMOTE_PROC_DOMAIN_SET_VCPUS + ProcDomainSetVcpus = 32 + // ProcDomainShutdown is libvirt's REMOTE_PROC_DOMAIN_SHUTDOWN + ProcDomainShutdown = 33 + // ProcDomainSuspend is libvirt's REMOTE_PROC_DOMAIN_SUSPEND + ProcDomainSuspend = 34 + // ProcDomainUndefine is libvirt's REMOTE_PROC_DOMAIN_UNDEFINE + ProcDomainUndefine = 35 + // ProcConnectListDefinedNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_NETWORKS + ProcConnectListDefinedNetworks = 36 + // ProcConnectListDomains is libvirt's REMOTE_PROC_CONNECT_LIST_DOMAINS + ProcConnectListDomains = 37 + // ProcConnectListNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_NETWORKS + ProcConnectListNetworks = 38 + // ProcNetworkCreate is libvirt's REMOTE_PROC_NETWORK_CREATE + ProcNetworkCreate = 39 + // ProcNetworkCreateXML is libvirt's REMOTE_PROC_NETWORK_CREATE_XML + ProcNetworkCreateXML = 40 + // ProcNetworkDefineXML is libvirt's REMOTE_PROC_NETWORK_DEFINE_XML + ProcNetworkDefineXML = 41 + // ProcNetworkDestroy is libvirt's REMOTE_PROC_NETWORK_DESTROY + ProcNetworkDestroy = 42 + // ProcNetworkGetXMLDesc is libvirt's REMOTE_PROC_NETWORK_GET_XML_DESC + ProcNetworkGetXMLDesc = 43 + // ProcNetworkGetAutostart is libvirt's REMOTE_PROC_NETWORK_GET_AUTOSTART + ProcNetworkGetAutostart = 44 + // ProcNetworkGetBridgeName is libvirt's REMOTE_PROC_NETWORK_GET_BRIDGE_NAME + ProcNetworkGetBridgeName = 45 + // ProcNetworkLookupByName is libvirt's REMOTE_PROC_NETWORK_LOOKUP_BY_NAME + ProcNetworkLookupByName = 46 + // ProcNetworkLookupByUUID is libvirt's REMOTE_PROC_NETWORK_LOOKUP_BY_UUID + ProcNetworkLookupByUUID = 47 + // ProcNetworkSetAutostart is libvirt's REMOTE_PROC_NETWORK_SET_AUTOSTART + ProcNetworkSetAutostart = 48 + // ProcNetworkUndefine is libvirt's REMOTE_PROC_NETWORK_UNDEFINE + ProcNetworkUndefine = 49 + // ProcConnectNumOfDefinedNetworks is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_NETWORKS + ProcConnectNumOfDefinedNetworks = 50 + // ProcConnectNumOfDomains is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DOMAINS + ProcConnectNumOfDomains = 51 + // ProcConnectNumOfNetworks is libvirt's REMOTE_PROC_CONNECT_NUM_OF_NETWORKS + ProcConnectNumOfNetworks = 52 + // ProcDomainCoreDump is libvirt's REMOTE_PROC_DOMAIN_CORE_DUMP + ProcDomainCoreDump = 53 + // ProcDomainRestore is libvirt's REMOTE_PROC_DOMAIN_RESTORE + ProcDomainRestore = 54 + // ProcDomainSave is libvirt's REMOTE_PROC_DOMAIN_SAVE + ProcDomainSave = 55 + // ProcDomainGetSchedulerType is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE + ProcDomainGetSchedulerType = 56 + // ProcDomainGetSchedulerParameters is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS + ProcDomainGetSchedulerParameters = 57 + // ProcDomainSetSchedulerParameters is libvirt's REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS + ProcDomainSetSchedulerParameters = 58 + // ProcConnectGetHostname is libvirt's REMOTE_PROC_CONNECT_GET_HOSTNAME + ProcConnectGetHostname = 59 + // ProcConnectSupportsFeature is libvirt's REMOTE_PROC_CONNECT_SUPPORTS_FEATURE + ProcConnectSupportsFeature = 60 + // ProcDomainMigratePrepare is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE + ProcDomainMigratePrepare = 61 + // ProcDomainMigratePerform is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM + ProcDomainMigratePerform = 62 + // ProcDomainMigrateFinish is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH + ProcDomainMigrateFinish = 63 + // ProcDomainBlockStats is libvirt's REMOTE_PROC_DOMAIN_BLOCK_STATS + ProcDomainBlockStats = 64 + // ProcDomainInterfaceStats is libvirt's REMOTE_PROC_DOMAIN_INTERFACE_STATS + ProcDomainInterfaceStats = 65 + // ProcAuthList is libvirt's REMOTE_PROC_AUTH_LIST + ProcAuthList = 66 + // ProcAuthSaslInit is libvirt's REMOTE_PROC_AUTH_SASL_INIT + ProcAuthSaslInit = 67 + // ProcAuthSaslStart is libvirt's REMOTE_PROC_AUTH_SASL_START + ProcAuthSaslStart = 68 + // ProcAuthSaslStep is libvirt's REMOTE_PROC_AUTH_SASL_STEP + ProcAuthSaslStep = 69 + // ProcAuthPolkit is libvirt's REMOTE_PROC_AUTH_POLKIT + ProcAuthPolkit = 70 + // ProcConnectNumOfStoragePools is libvirt's REMOTE_PROC_CONNECT_NUM_OF_STORAGE_POOLS + ProcConnectNumOfStoragePools = 71 + // ProcConnectListStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_STORAGE_POOLS + ProcConnectListStoragePools = 72 + // ProcConnectNumOfDefinedStoragePools is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_STORAGE_POOLS + ProcConnectNumOfDefinedStoragePools = 73 + // ProcConnectListDefinedStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_STORAGE_POOLS + ProcConnectListDefinedStoragePools = 74 + // ProcConnectFindStoragePoolSources is libvirt's REMOTE_PROC_CONNECT_FIND_STORAGE_POOL_SOURCES + ProcConnectFindStoragePoolSources = 75 + // ProcStoragePoolCreateXML is libvirt's REMOTE_PROC_STORAGE_POOL_CREATE_XML + ProcStoragePoolCreateXML = 76 + // ProcStoragePoolDefineXML is libvirt's REMOTE_PROC_STORAGE_POOL_DEFINE_XML + ProcStoragePoolDefineXML = 77 + // ProcStoragePoolCreate is libvirt's REMOTE_PROC_STORAGE_POOL_CREATE + ProcStoragePoolCreate = 78 + // ProcStoragePoolBuild is libvirt's REMOTE_PROC_STORAGE_POOL_BUILD + ProcStoragePoolBuild = 79 + // ProcStoragePoolDestroy is libvirt's REMOTE_PROC_STORAGE_POOL_DESTROY + ProcStoragePoolDestroy = 80 + // ProcStoragePoolDelete is libvirt's REMOTE_PROC_STORAGE_POOL_DELETE + ProcStoragePoolDelete = 81 + // ProcStoragePoolUndefine is libvirt's REMOTE_PROC_STORAGE_POOL_UNDEFINE + ProcStoragePoolUndefine = 82 + // ProcStoragePoolRefresh is libvirt's REMOTE_PROC_STORAGE_POOL_REFRESH + ProcStoragePoolRefresh = 83 + // ProcStoragePoolLookupByName is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME + ProcStoragePoolLookupByName = 84 + // ProcStoragePoolLookupByUUID is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID + ProcStoragePoolLookupByUUID = 85 + // ProcStoragePoolLookupByVolume is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME + ProcStoragePoolLookupByVolume = 86 + // ProcStoragePoolGetInfo is libvirt's REMOTE_PROC_STORAGE_POOL_GET_INFO + ProcStoragePoolGetInfo = 87 + // ProcStoragePoolGetXMLDesc is libvirt's REMOTE_PROC_STORAGE_POOL_GET_XML_DESC + ProcStoragePoolGetXMLDesc = 88 + // ProcStoragePoolGetAutostart is libvirt's REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART + ProcStoragePoolGetAutostart = 89 + // ProcStoragePoolSetAutostart is libvirt's REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART + ProcStoragePoolSetAutostart = 90 + // ProcStoragePoolNumOfVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES + ProcStoragePoolNumOfVolumes = 91 + // ProcStoragePoolListVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES + ProcStoragePoolListVolumes = 92 + // ProcStorageVolCreateXML is libvirt's REMOTE_PROC_STORAGE_VOL_CREATE_XML + ProcStorageVolCreateXML = 93 + // ProcStorageVolDelete is libvirt's REMOTE_PROC_STORAGE_VOL_DELETE + ProcStorageVolDelete = 94 + // ProcStorageVolLookupByName is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME + ProcStorageVolLookupByName = 95 + // ProcStorageVolLookupByKey is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY + ProcStorageVolLookupByKey = 96 + // ProcStorageVolLookupByPath is libvirt's REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH + ProcStorageVolLookupByPath = 97 + // ProcStorageVolGetInfo is libvirt's REMOTE_PROC_STORAGE_VOL_GET_INFO + ProcStorageVolGetInfo = 98 + // ProcStorageVolGetXMLDesc is libvirt's REMOTE_PROC_STORAGE_VOL_GET_XML_DESC + ProcStorageVolGetXMLDesc = 99 + // ProcStorageVolGetPath is libvirt's REMOTE_PROC_STORAGE_VOL_GET_PATH + ProcStorageVolGetPath = 100 + // ProcNodeGetCellsFreeMemory is libvirt's REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY + ProcNodeGetCellsFreeMemory = 101 + // ProcNodeGetFreeMemory is libvirt's REMOTE_PROC_NODE_GET_FREE_MEMORY + ProcNodeGetFreeMemory = 102 + // ProcDomainBlockPeek is libvirt's REMOTE_PROC_DOMAIN_BLOCK_PEEK + ProcDomainBlockPeek = 103 + // ProcDomainMemoryPeek is libvirt's REMOTE_PROC_DOMAIN_MEMORY_PEEK + ProcDomainMemoryPeek = 104 + // ProcConnectDomainEventRegister is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER + ProcConnectDomainEventRegister = 105 + // ProcConnectDomainEventDeregister is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER + ProcConnectDomainEventDeregister = 106 + // ProcDomainEventLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE + ProcDomainEventLifecycle = 107 + // ProcDomainMigratePrepare2 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2 + ProcDomainMigratePrepare2 = 108 + // ProcDomainMigrateFinish2 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH2 + ProcDomainMigrateFinish2 = 109 + // ProcConnectGetUri is libvirt's REMOTE_PROC_CONNECT_GET_URI + ProcConnectGetUri = 110 + // ProcNodeNumOfDevices is libvirt's REMOTE_PROC_NODE_NUM_OF_DEVICES + ProcNodeNumOfDevices = 111 + // ProcNodeListDevices is libvirt's REMOTE_PROC_NODE_LIST_DEVICES + ProcNodeListDevices = 112 + // ProcNodeDeviceLookupByName is libvirt's REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME + ProcNodeDeviceLookupByName = 113 + // ProcNodeDeviceGetXMLDesc is libvirt's REMOTE_PROC_NODE_DEVICE_GET_XML_DESC + ProcNodeDeviceGetXMLDesc = 114 + // ProcNodeDeviceGetParent is libvirt's REMOTE_PROC_NODE_DEVICE_GET_PARENT + ProcNodeDeviceGetParent = 115 + // ProcNodeDeviceNumOfCaps is libvirt's REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS + ProcNodeDeviceNumOfCaps = 116 + // ProcNodeDeviceListCaps is libvirt's REMOTE_PROC_NODE_DEVICE_LIST_CAPS + ProcNodeDeviceListCaps = 117 + // ProcNodeDeviceDettach is libvirt's REMOTE_PROC_NODE_DEVICE_DETTACH + ProcNodeDeviceDettach = 118 + // ProcNodeDeviceReAttach is libvirt's REMOTE_PROC_NODE_DEVICE_RE_ATTACH + ProcNodeDeviceReAttach = 119 + // ProcNodeDeviceReset is libvirt's REMOTE_PROC_NODE_DEVICE_RESET + ProcNodeDeviceReset = 120 + // ProcDomainGetSecurityLabel is libvirt's REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL + ProcDomainGetSecurityLabel = 121 + // ProcNodeGetSecurityModel is libvirt's REMOTE_PROC_NODE_GET_SECURITY_MODEL + ProcNodeGetSecurityModel = 122 + // ProcNodeDeviceCreateXML is libvirt's REMOTE_PROC_NODE_DEVICE_CREATE_XML + ProcNodeDeviceCreateXML = 123 + // ProcNodeDeviceDestroy is libvirt's REMOTE_PROC_NODE_DEVICE_DESTROY + ProcNodeDeviceDestroy = 124 + // ProcStorageVolCreateXMLFrom is libvirt's REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM + ProcStorageVolCreateXMLFrom = 125 + // ProcConnectNumOfInterfaces is libvirt's REMOTE_PROC_CONNECT_NUM_OF_INTERFACES + ProcConnectNumOfInterfaces = 126 + // ProcConnectListInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_INTERFACES + ProcConnectListInterfaces = 127 + // ProcInterfaceLookupByName is libvirt's REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME + ProcInterfaceLookupByName = 128 + // ProcInterfaceLookupByMacString is libvirt's REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING + ProcInterfaceLookupByMacString = 129 + // ProcInterfaceGetXMLDesc is libvirt's REMOTE_PROC_INTERFACE_GET_XML_DESC + ProcInterfaceGetXMLDesc = 130 + // ProcInterfaceDefineXML is libvirt's REMOTE_PROC_INTERFACE_DEFINE_XML + ProcInterfaceDefineXML = 131 + // ProcInterfaceUndefine is libvirt's REMOTE_PROC_INTERFACE_UNDEFINE + ProcInterfaceUndefine = 132 + // ProcInterfaceCreate is libvirt's REMOTE_PROC_INTERFACE_CREATE + ProcInterfaceCreate = 133 + // ProcInterfaceDestroy is libvirt's REMOTE_PROC_INTERFACE_DESTROY + ProcInterfaceDestroy = 134 + // ProcConnectDomainXMLFromNative is libvirt's REMOTE_PROC_CONNECT_DOMAIN_XML_FROM_NATIVE + ProcConnectDomainXMLFromNative = 135 + // ProcConnectDomainXMLToNative is libvirt's REMOTE_PROC_CONNECT_DOMAIN_XML_TO_NATIVE + ProcConnectDomainXMLToNative = 136 + // ProcConnectNumOfDefinedInterfaces is libvirt's REMOTE_PROC_CONNECT_NUM_OF_DEFINED_INTERFACES + ProcConnectNumOfDefinedInterfaces = 137 + // ProcConnectListDefinedInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_DEFINED_INTERFACES + ProcConnectListDefinedInterfaces = 138 + // ProcConnectNumOfSecrets is libvirt's REMOTE_PROC_CONNECT_NUM_OF_SECRETS + ProcConnectNumOfSecrets = 139 + // ProcConnectListSecrets is libvirt's REMOTE_PROC_CONNECT_LIST_SECRETS + ProcConnectListSecrets = 140 + // ProcSecretLookupByUUID is libvirt's REMOTE_PROC_SECRET_LOOKUP_BY_UUID + ProcSecretLookupByUUID = 141 + // ProcSecretDefineXML is libvirt's REMOTE_PROC_SECRET_DEFINE_XML + ProcSecretDefineXML = 142 + // ProcSecretGetXMLDesc is libvirt's REMOTE_PROC_SECRET_GET_XML_DESC + ProcSecretGetXMLDesc = 143 + // ProcSecretSetValue is libvirt's REMOTE_PROC_SECRET_SET_VALUE + ProcSecretSetValue = 144 + // ProcSecretGetValue is libvirt's REMOTE_PROC_SECRET_GET_VALUE + ProcSecretGetValue = 145 + // ProcSecretUndefine is libvirt's REMOTE_PROC_SECRET_UNDEFINE + ProcSecretUndefine = 146 + // ProcSecretLookupByUsage is libvirt's REMOTE_PROC_SECRET_LOOKUP_BY_USAGE + ProcSecretLookupByUsage = 147 + // ProcDomainMigratePrepareTunnel is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL + ProcDomainMigratePrepareTunnel = 148 + // ProcConnectIsSecure is libvirt's REMOTE_PROC_CONNECT_IS_SECURE + ProcConnectIsSecure = 149 + // ProcDomainIsActive is libvirt's REMOTE_PROC_DOMAIN_IS_ACTIVE + ProcDomainIsActive = 150 + // ProcDomainIsPersistent is libvirt's REMOTE_PROC_DOMAIN_IS_PERSISTENT + ProcDomainIsPersistent = 151 + // ProcNetworkIsActive is libvirt's REMOTE_PROC_NETWORK_IS_ACTIVE + ProcNetworkIsActive = 152 + // ProcNetworkIsPersistent is libvirt's REMOTE_PROC_NETWORK_IS_PERSISTENT + ProcNetworkIsPersistent = 153 + // ProcStoragePoolIsActive is libvirt's REMOTE_PROC_STORAGE_POOL_IS_ACTIVE + ProcStoragePoolIsActive = 154 + // ProcStoragePoolIsPersistent is libvirt's REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT + ProcStoragePoolIsPersistent = 155 + // ProcInterfaceIsActive is libvirt's REMOTE_PROC_INTERFACE_IS_ACTIVE + ProcInterfaceIsActive = 156 + // ProcConnectGetLibVersion is libvirt's REMOTE_PROC_CONNECT_GET_LIB_VERSION + ProcConnectGetLibVersion = 157 + // ProcConnectCompareCPU is libvirt's REMOTE_PROC_CONNECT_COMPARE_CPU + ProcConnectCompareCPU = 158 + // ProcDomainMemoryStats is libvirt's REMOTE_PROC_DOMAIN_MEMORY_STATS + ProcDomainMemoryStats = 159 + // ProcDomainAttachDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS + ProcDomainAttachDeviceFlags = 160 + // ProcDomainDetachDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS + ProcDomainDetachDeviceFlags = 161 + // ProcConnectBaselineCPU is libvirt's REMOTE_PROC_CONNECT_BASELINE_CPU + ProcConnectBaselineCPU = 162 + // ProcDomainGetJobInfo is libvirt's REMOTE_PROC_DOMAIN_GET_JOB_INFO + ProcDomainGetJobInfo = 163 + // ProcDomainAbortJob is libvirt's REMOTE_PROC_DOMAIN_ABORT_JOB + ProcDomainAbortJob = 164 + // ProcStorageVolWipe is libvirt's REMOTE_PROC_STORAGE_VOL_WIPE + ProcStorageVolWipe = 165 + // ProcDomainMigrateSetMaxDowntime is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME + ProcDomainMigrateSetMaxDowntime = 166 + // ProcConnectDomainEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY + ProcConnectDomainEventRegisterAny = 167 + // ProcConnectDomainEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY + ProcConnectDomainEventDeregisterAny = 168 + // ProcDomainEventReboot is libvirt's REMOTE_PROC_DOMAIN_EVENT_REBOOT + ProcDomainEventReboot = 169 + // ProcDomainEventRtcChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE + ProcDomainEventRtcChange = 170 + // ProcDomainEventWatchdog is libvirt's REMOTE_PROC_DOMAIN_EVENT_WATCHDOG + ProcDomainEventWatchdog = 171 + // ProcDomainEventIOError is libvirt's REMOTE_PROC_DOMAIN_EVENT_IO_ERROR + ProcDomainEventIOError = 172 + // ProcDomainEventGraphics is libvirt's REMOTE_PROC_DOMAIN_EVENT_GRAPHICS + ProcDomainEventGraphics = 173 + // ProcDomainUpdateDeviceFlags is libvirt's REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS + ProcDomainUpdateDeviceFlags = 174 + // ProcNwfilterLookupByName is libvirt's REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME + ProcNwfilterLookupByName = 175 + // ProcNwfilterLookupByUUID is libvirt's REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID + ProcNwfilterLookupByUUID = 176 + // ProcNwfilterGetXMLDesc is libvirt's REMOTE_PROC_NWFILTER_GET_XML_DESC + ProcNwfilterGetXMLDesc = 177 + // ProcConnectNumOfNwfilters is libvirt's REMOTE_PROC_CONNECT_NUM_OF_NWFILTERS + ProcConnectNumOfNwfilters = 178 + // ProcConnectListNwfilters is libvirt's REMOTE_PROC_CONNECT_LIST_NWFILTERS + ProcConnectListNwfilters = 179 + // ProcNwfilterDefineXML is libvirt's REMOTE_PROC_NWFILTER_DEFINE_XML + ProcNwfilterDefineXML = 180 + // ProcNwfilterUndefine is libvirt's REMOTE_PROC_NWFILTER_UNDEFINE + ProcNwfilterUndefine = 181 + // ProcDomainManagedSave is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE + ProcDomainManagedSave = 182 + // ProcDomainHasManagedSaveImage is libvirt's REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE + ProcDomainHasManagedSaveImage = 183 + // ProcDomainManagedSaveRemove is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE + ProcDomainManagedSaveRemove = 184 + // ProcDomainSnapshotCreateXML is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML + ProcDomainSnapshotCreateXML = 185 + // ProcDomainSnapshotGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_GET_XML_DESC + ProcDomainSnapshotGetXMLDesc = 186 + // ProcDomainSnapshotNum is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_NUM + ProcDomainSnapshotNum = 187 + // ProcDomainSnapshotListNames is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES + ProcDomainSnapshotListNames = 188 + // ProcDomainSnapshotLookupByName is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME + ProcDomainSnapshotLookupByName = 189 + // ProcDomainHasCurrentSnapshot is libvirt's REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT + ProcDomainHasCurrentSnapshot = 190 + // ProcDomainSnapshotCurrent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT + ProcDomainSnapshotCurrent = 191 + // ProcDomainRevertToSnapshot is libvirt's REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT + ProcDomainRevertToSnapshot = 192 + // ProcDomainSnapshotDelete is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE + ProcDomainSnapshotDelete = 193 + // ProcDomainGetBlockInfo is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_INFO + ProcDomainGetBlockInfo = 194 + // ProcDomainEventIOErrorReason is libvirt's REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON + ProcDomainEventIOErrorReason = 195 + // ProcDomainCreateWithFlags is libvirt's REMOTE_PROC_DOMAIN_CREATE_WITH_FLAGS + ProcDomainCreateWithFlags = 196 + // ProcDomainSetMemoryParameters is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_PARAMETERS + ProcDomainSetMemoryParameters = 197 + // ProcDomainGetMemoryParameters is libvirt's REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS + ProcDomainGetMemoryParameters = 198 + // ProcDomainSetVcpusFlags is libvirt's REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS + ProcDomainSetVcpusFlags = 199 + // ProcDomainGetVcpusFlags is libvirt's REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS + ProcDomainGetVcpusFlags = 200 + // ProcDomainOpenConsole is libvirt's REMOTE_PROC_DOMAIN_OPEN_CONSOLE + ProcDomainOpenConsole = 201 + // ProcDomainIsUpdated is libvirt's REMOTE_PROC_DOMAIN_IS_UPDATED + ProcDomainIsUpdated = 202 + // ProcConnectGetSysinfo is libvirt's REMOTE_PROC_CONNECT_GET_SYSINFO + ProcConnectGetSysinfo = 203 + // ProcDomainSetMemoryFlags is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS + ProcDomainSetMemoryFlags = 204 + // ProcDomainSetBlkioParameters is libvirt's REMOTE_PROC_DOMAIN_SET_BLKIO_PARAMETERS + ProcDomainSetBlkioParameters = 205 + // ProcDomainGetBlkioParameters is libvirt's REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS + ProcDomainGetBlkioParameters = 206 + // ProcDomainMigrateSetMaxSpeed is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED + ProcDomainMigrateSetMaxSpeed = 207 + // ProcStorageVolUpload is libvirt's REMOTE_PROC_STORAGE_VOL_UPLOAD + ProcStorageVolUpload = 208 + // ProcStorageVolDownload is libvirt's REMOTE_PROC_STORAGE_VOL_DOWNLOAD + ProcStorageVolDownload = 209 + // ProcDomainInjectNmi is libvirt's REMOTE_PROC_DOMAIN_INJECT_NMI + ProcDomainInjectNmi = 210 + // ProcDomainScreenshot is libvirt's REMOTE_PROC_DOMAIN_SCREENSHOT + ProcDomainScreenshot = 211 + // ProcDomainGetState is libvirt's REMOTE_PROC_DOMAIN_GET_STATE + ProcDomainGetState = 212 + // ProcDomainMigrateBegin3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3 + ProcDomainMigrateBegin3 = 213 + // ProcDomainMigratePrepare3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3 + ProcDomainMigratePrepare3 = 214 + // ProcDomainMigratePrepareTunnel3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3 + ProcDomainMigratePrepareTunnel3 = 215 + // ProcDomainMigratePerform3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3 + ProcDomainMigratePerform3 = 216 + // ProcDomainMigrateFinish3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH3 + ProcDomainMigrateFinish3 = 217 + // ProcDomainMigrateConfirm3 is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3 + ProcDomainMigrateConfirm3 = 218 + // ProcDomainSetSchedulerParametersFlags is libvirt's REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS_FLAGS + ProcDomainSetSchedulerParametersFlags = 219 + // ProcInterfaceChangeBegin is libvirt's REMOTE_PROC_INTERFACE_CHANGE_BEGIN + ProcInterfaceChangeBegin = 220 + // ProcInterfaceChangeCommit is libvirt's REMOTE_PROC_INTERFACE_CHANGE_COMMIT + ProcInterfaceChangeCommit = 221 + // ProcInterfaceChangeRollback is libvirt's REMOTE_PROC_INTERFACE_CHANGE_ROLLBACK + ProcInterfaceChangeRollback = 222 + // ProcDomainGetSchedulerParametersFlags is libvirt's REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS_FLAGS + ProcDomainGetSchedulerParametersFlags = 223 + // ProcDomainEventControlError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR + ProcDomainEventControlError = 224 + // ProcDomainPinVcpuFlags is libvirt's REMOTE_PROC_DOMAIN_PIN_VCPU_FLAGS + ProcDomainPinVcpuFlags = 225 + // ProcDomainSendKey is libvirt's REMOTE_PROC_DOMAIN_SEND_KEY + ProcDomainSendKey = 226 + // ProcNodeGetCPUStats is libvirt's REMOTE_PROC_NODE_GET_CPU_STATS + ProcNodeGetCPUStats = 227 + // ProcNodeGetMemoryStats is libvirt's REMOTE_PROC_NODE_GET_MEMORY_STATS + ProcNodeGetMemoryStats = 228 + // ProcDomainGetControlInfo is libvirt's REMOTE_PROC_DOMAIN_GET_CONTROL_INFO + ProcDomainGetControlInfo = 229 + // ProcDomainGetVcpuPinInfo is libvirt's REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO + ProcDomainGetVcpuPinInfo = 230 + // ProcDomainUndefineFlags is libvirt's REMOTE_PROC_DOMAIN_UNDEFINE_FLAGS + ProcDomainUndefineFlags = 231 + // ProcDomainSaveFlags is libvirt's REMOTE_PROC_DOMAIN_SAVE_FLAGS + ProcDomainSaveFlags = 232 + // ProcDomainRestoreFlags is libvirt's REMOTE_PROC_DOMAIN_RESTORE_FLAGS + ProcDomainRestoreFlags = 233 + // ProcDomainDestroyFlags is libvirt's REMOTE_PROC_DOMAIN_DESTROY_FLAGS + ProcDomainDestroyFlags = 234 + // ProcDomainSaveImageGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_SAVE_IMAGE_GET_XML_DESC + ProcDomainSaveImageGetXMLDesc = 235 + // ProcDomainSaveImageDefineXML is libvirt's REMOTE_PROC_DOMAIN_SAVE_IMAGE_DEFINE_XML + ProcDomainSaveImageDefineXML = 236 + // ProcDomainBlockJobAbort is libvirt's REMOTE_PROC_DOMAIN_BLOCK_JOB_ABORT + ProcDomainBlockJobAbort = 237 + // ProcDomainGetBlockJobInfo is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_JOB_INFO + ProcDomainGetBlockJobInfo = 238 + // ProcDomainBlockJobSetSpeed is libvirt's REMOTE_PROC_DOMAIN_BLOCK_JOB_SET_SPEED + ProcDomainBlockJobSetSpeed = 239 + // ProcDomainBlockPull is libvirt's REMOTE_PROC_DOMAIN_BLOCK_PULL + ProcDomainBlockPull = 240 + // ProcDomainEventBlockJob is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB + ProcDomainEventBlockJob = 241 + // ProcDomainMigrateGetMaxSpeed is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_SPEED + ProcDomainMigrateGetMaxSpeed = 242 + // ProcDomainBlockStatsFlags is libvirt's REMOTE_PROC_DOMAIN_BLOCK_STATS_FLAGS + ProcDomainBlockStatsFlags = 243 + // ProcDomainSnapshotGetParent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_GET_PARENT + ProcDomainSnapshotGetParent = 244 + // ProcDomainReset is libvirt's REMOTE_PROC_DOMAIN_RESET + ProcDomainReset = 245 + // ProcDomainSnapshotNumChildren is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_NUM_CHILDREN + ProcDomainSnapshotNumChildren = 246 + // ProcDomainSnapshotListChildrenNames is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_CHILDREN_NAMES + ProcDomainSnapshotListChildrenNames = 247 + // ProcDomainEventDiskChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE + ProcDomainEventDiskChange = 248 + // ProcDomainOpenGraphics is libvirt's REMOTE_PROC_DOMAIN_OPEN_GRAPHICS + ProcDomainOpenGraphics = 249 + // ProcNodeSuspendForDuration is libvirt's REMOTE_PROC_NODE_SUSPEND_FOR_DURATION + ProcNodeSuspendForDuration = 250 + // ProcDomainBlockResize is libvirt's REMOTE_PROC_DOMAIN_BLOCK_RESIZE + ProcDomainBlockResize = 251 + // ProcDomainSetBlockIOTune is libvirt's REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE + ProcDomainSetBlockIOTune = 252 + // ProcDomainGetBlockIOTune is libvirt's REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE + ProcDomainGetBlockIOTune = 253 + // ProcDomainSetNumaParameters is libvirt's REMOTE_PROC_DOMAIN_SET_NUMA_PARAMETERS + ProcDomainSetNumaParameters = 254 + // ProcDomainGetNumaParameters is libvirt's REMOTE_PROC_DOMAIN_GET_NUMA_PARAMETERS + ProcDomainGetNumaParameters = 255 + // ProcDomainSetInterfaceParameters is libvirt's REMOTE_PROC_DOMAIN_SET_INTERFACE_PARAMETERS + ProcDomainSetInterfaceParameters = 256 + // ProcDomainGetInterfaceParameters is libvirt's REMOTE_PROC_DOMAIN_GET_INTERFACE_PARAMETERS + ProcDomainGetInterfaceParameters = 257 + // ProcDomainShutdownFlags is libvirt's REMOTE_PROC_DOMAIN_SHUTDOWN_FLAGS + ProcDomainShutdownFlags = 258 + // ProcStorageVolWipePattern is libvirt's REMOTE_PROC_STORAGE_VOL_WIPE_PATTERN + ProcStorageVolWipePattern = 259 + // ProcStorageVolResize is libvirt's REMOTE_PROC_STORAGE_VOL_RESIZE + ProcStorageVolResize = 260 + // ProcDomainPmSuspendForDuration is libvirt's REMOTE_PROC_DOMAIN_PM_SUSPEND_FOR_DURATION + ProcDomainPmSuspendForDuration = 261 + // ProcDomainGetCPUStats is libvirt's REMOTE_PROC_DOMAIN_GET_CPU_STATS + ProcDomainGetCPUStats = 262 + // ProcDomainGetDiskErrors is libvirt's REMOTE_PROC_DOMAIN_GET_DISK_ERRORS + ProcDomainGetDiskErrors = 263 + // ProcDomainSetMetadata is libvirt's REMOTE_PROC_DOMAIN_SET_METADATA + ProcDomainSetMetadata = 264 + // ProcDomainGetMetadata is libvirt's REMOTE_PROC_DOMAIN_GET_METADATA + ProcDomainGetMetadata = 265 + // ProcDomainBlockRebase is libvirt's REMOTE_PROC_DOMAIN_BLOCK_REBASE + ProcDomainBlockRebase = 266 + // ProcDomainPmWakeup is libvirt's REMOTE_PROC_DOMAIN_PM_WAKEUP + ProcDomainPmWakeup = 267 + // ProcDomainEventTrayChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE + ProcDomainEventTrayChange = 268 + // ProcDomainEventPmwakeup is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP + ProcDomainEventPmwakeup = 269 + // ProcDomainEventPmsuspend is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND + ProcDomainEventPmsuspend = 270 + // ProcDomainSnapshotIsCurrent is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_IS_CURRENT + ProcDomainSnapshotIsCurrent = 271 + // ProcDomainSnapshotHasMetadata is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_HAS_METADATA + ProcDomainSnapshotHasMetadata = 272 + // ProcConnectListAllDomains is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS + ProcConnectListAllDomains = 273 + // ProcDomainListAllSnapshots is libvirt's REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS + ProcDomainListAllSnapshots = 274 + // ProcDomainSnapshotListAllChildren is libvirt's REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_ALL_CHILDREN + ProcDomainSnapshotListAllChildren = 275 + // ProcDomainEventBalloonChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE + ProcDomainEventBalloonChange = 276 + // ProcDomainGetHostname is libvirt's REMOTE_PROC_DOMAIN_GET_HOSTNAME + ProcDomainGetHostname = 277 + // ProcDomainGetSecurityLabelList is libvirt's REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL_LIST + ProcDomainGetSecurityLabelList = 278 + // ProcDomainPinEmulator is libvirt's REMOTE_PROC_DOMAIN_PIN_EMULATOR + ProcDomainPinEmulator = 279 + // ProcDomainGetEmulatorPinInfo is libvirt's REMOTE_PROC_DOMAIN_GET_EMULATOR_PIN_INFO + ProcDomainGetEmulatorPinInfo = 280 + // ProcConnectListAllStoragePools is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS + ProcConnectListAllStoragePools = 281 + // ProcStoragePoolListAllVolumes is libvirt's REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES + ProcStoragePoolListAllVolumes = 282 + // ProcConnectListAllNetworks is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS + ProcConnectListAllNetworks = 283 + // ProcConnectListAllInterfaces is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES + ProcConnectListAllInterfaces = 284 + // ProcConnectListAllNodeDevices is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES + ProcConnectListAllNodeDevices = 285 + // ProcConnectListAllNwfilters is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS + ProcConnectListAllNwfilters = 286 + // ProcConnectListAllSecrets is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_SECRETS + ProcConnectListAllSecrets = 287 + // ProcNodeSetMemoryParameters is libvirt's REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS + ProcNodeSetMemoryParameters = 288 + // ProcNodeGetMemoryParameters is libvirt's REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS + ProcNodeGetMemoryParameters = 289 + // ProcDomainBlockCommit is libvirt's REMOTE_PROC_DOMAIN_BLOCK_COMMIT + ProcDomainBlockCommit = 290 + // ProcNetworkUpdate is libvirt's REMOTE_PROC_NETWORK_UPDATE + ProcNetworkUpdate = 291 + // ProcDomainEventPmsuspendDisk is libvirt's REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK + ProcDomainEventPmsuspendDisk = 292 + // ProcNodeGetCPUMap is libvirt's REMOTE_PROC_NODE_GET_CPU_MAP + ProcNodeGetCPUMap = 293 + // ProcDomainFstrim is libvirt's REMOTE_PROC_DOMAIN_FSTRIM + ProcDomainFstrim = 294 + // ProcDomainSendProcessSignal is libvirt's REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL + ProcDomainSendProcessSignal = 295 + // ProcDomainOpenChannel is libvirt's REMOTE_PROC_DOMAIN_OPEN_CHANNEL + ProcDomainOpenChannel = 296 + // ProcNodeDeviceLookupScsiHostByWwn is libvirt's REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN + ProcNodeDeviceLookupScsiHostByWwn = 297 + // ProcDomainGetJobStats is libvirt's REMOTE_PROC_DOMAIN_GET_JOB_STATS + ProcDomainGetJobStats = 298 + // ProcDomainMigrateGetCompressionCache is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE + ProcDomainMigrateGetCompressionCache = 299 + // ProcDomainMigrateSetCompressionCache is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE + ProcDomainMigrateSetCompressionCache = 300 + // ProcNodeDeviceDetachFlags is libvirt's REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS + ProcNodeDeviceDetachFlags = 301 + // ProcDomainMigrateBegin3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS + ProcDomainMigrateBegin3Params = 302 + // ProcDomainMigratePrepare3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS + ProcDomainMigratePrepare3Params = 303 + // ProcDomainMigratePrepareTunnel3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS + ProcDomainMigratePrepareTunnel3Params = 304 + // ProcDomainMigratePerform3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS + ProcDomainMigratePerform3Params = 305 + // ProcDomainMigrateFinish3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS + ProcDomainMigrateFinish3Params = 306 + // ProcDomainMigrateConfirm3Params is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS + ProcDomainMigrateConfirm3Params = 307 + // ProcDomainSetMemoryStatsPeriod is libvirt's REMOTE_PROC_DOMAIN_SET_MEMORY_STATS_PERIOD + ProcDomainSetMemoryStatsPeriod = 308 + // ProcDomainCreateXMLWithFiles is libvirt's REMOTE_PROC_DOMAIN_CREATE_XML_WITH_FILES + ProcDomainCreateXMLWithFiles = 309 + // ProcDomainCreateWithFiles is libvirt's REMOTE_PROC_DOMAIN_CREATE_WITH_FILES + ProcDomainCreateWithFiles = 310 + // ProcDomainEventDeviceRemoved is libvirt's REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED + ProcDomainEventDeviceRemoved = 311 + // ProcConnectGetCPUModelNames is libvirt's REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES + ProcConnectGetCPUModelNames = 312 + // ProcConnectNetworkEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY + ProcConnectNetworkEventRegisterAny = 313 + // ProcConnectNetworkEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY + ProcConnectNetworkEventDeregisterAny = 314 + // ProcNetworkEventLifecycle is libvirt's REMOTE_PROC_NETWORK_EVENT_LIFECYCLE + ProcNetworkEventLifecycle = 315 + // ProcConnectDomainEventCallbackRegisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY + ProcConnectDomainEventCallbackRegisterAny = 316 + // ProcConnectDomainEventCallbackDeregisterAny is libvirt's REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY + ProcConnectDomainEventCallbackDeregisterAny = 317 + // ProcDomainEventCallbackLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE + ProcDomainEventCallbackLifecycle = 318 + // ProcDomainEventCallbackReboot is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT + ProcDomainEventCallbackReboot = 319 + // ProcDomainEventCallbackRtcChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE + ProcDomainEventCallbackRtcChange = 320 + // ProcDomainEventCallbackWatchdog is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG + ProcDomainEventCallbackWatchdog = 321 + // ProcDomainEventCallbackIOError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR + ProcDomainEventCallbackIOError = 322 + // ProcDomainEventCallbackGraphics is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS + ProcDomainEventCallbackGraphics = 323 + // ProcDomainEventCallbackIOErrorReason is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON + ProcDomainEventCallbackIOErrorReason = 324 + // ProcDomainEventCallbackControlError is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR + ProcDomainEventCallbackControlError = 325 + // ProcDomainEventCallbackBlockJob is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB + ProcDomainEventCallbackBlockJob = 326 + // ProcDomainEventCallbackDiskChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE + ProcDomainEventCallbackDiskChange = 327 + // ProcDomainEventCallbackTrayChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE + ProcDomainEventCallbackTrayChange = 328 + // ProcDomainEventCallbackPmwakeup is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP + ProcDomainEventCallbackPmwakeup = 329 + // ProcDomainEventCallbackPmsuspend is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND + ProcDomainEventCallbackPmsuspend = 330 + // ProcDomainEventCallbackBalloonChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE + ProcDomainEventCallbackBalloonChange = 331 + // ProcDomainEventCallbackPmsuspendDisk is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK + ProcDomainEventCallbackPmsuspendDisk = 332 + // ProcDomainEventCallbackDeviceRemoved is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED + ProcDomainEventCallbackDeviceRemoved = 333 + // ProcDomainCoreDumpWithFormat is libvirt's REMOTE_PROC_DOMAIN_CORE_DUMP_WITH_FORMAT + ProcDomainCoreDumpWithFormat = 334 + // ProcDomainFsfreeze is libvirt's REMOTE_PROC_DOMAIN_FSFREEZE + ProcDomainFsfreeze = 335 + // ProcDomainFsthaw is libvirt's REMOTE_PROC_DOMAIN_FSTHAW + ProcDomainFsthaw = 336 + // ProcDomainGetTime is libvirt's REMOTE_PROC_DOMAIN_GET_TIME + ProcDomainGetTime = 337 + // ProcDomainSetTime is libvirt's REMOTE_PROC_DOMAIN_SET_TIME + ProcDomainSetTime = 338 + // ProcDomainEventBlockJob2 is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB_2 + ProcDomainEventBlockJob2 = 339 + // ProcNodeGetFreePages is libvirt's REMOTE_PROC_NODE_GET_FREE_PAGES + ProcNodeGetFreePages = 340 + // ProcNetworkGetDhcpLeases is libvirt's REMOTE_PROC_NETWORK_GET_DHCP_LEASES + ProcNetworkGetDhcpLeases = 341 + // ProcConnectGetDomainCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_DOMAIN_CAPABILITIES + ProcConnectGetDomainCapabilities = 342 + // ProcDomainOpenGraphicsFd is libvirt's REMOTE_PROC_DOMAIN_OPEN_GRAPHICS_FD + ProcDomainOpenGraphicsFd = 343 + // ProcConnectGetAllDomainStats is libvirt's REMOTE_PROC_CONNECT_GET_ALL_DOMAIN_STATS + ProcConnectGetAllDomainStats = 344 + // ProcDomainBlockCopy is libvirt's REMOTE_PROC_DOMAIN_BLOCK_COPY + ProcDomainBlockCopy = 345 + // ProcDomainEventCallbackTunable is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TUNABLE + ProcDomainEventCallbackTunable = 346 + // ProcNodeAllocPages is libvirt's REMOTE_PROC_NODE_ALLOC_PAGES + ProcNodeAllocPages = 347 + // ProcDomainEventCallbackAgentLifecycle is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_AGENT_LIFECYCLE + ProcDomainEventCallbackAgentLifecycle = 348 + // ProcDomainGetFsinfo is libvirt's REMOTE_PROC_DOMAIN_GET_FSINFO + ProcDomainGetFsinfo = 349 + // ProcDomainDefineXMLFlags is libvirt's REMOTE_PROC_DOMAIN_DEFINE_XML_FLAGS + ProcDomainDefineXMLFlags = 350 + // ProcDomainGetIothreadInfo is libvirt's REMOTE_PROC_DOMAIN_GET_IOTHREAD_INFO + ProcDomainGetIothreadInfo = 351 + // ProcDomainPinIothread is libvirt's REMOTE_PROC_DOMAIN_PIN_IOTHREAD + ProcDomainPinIothread = 352 + // ProcDomainInterfaceAddresses is libvirt's REMOTE_PROC_DOMAIN_INTERFACE_ADDRESSES + ProcDomainInterfaceAddresses = 353 + // ProcDomainEventCallbackDeviceAdded is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_ADDED + ProcDomainEventCallbackDeviceAdded = 354 + // ProcDomainAddIothread is libvirt's REMOTE_PROC_DOMAIN_ADD_IOTHREAD + ProcDomainAddIothread = 355 + // ProcDomainDelIothread is libvirt's REMOTE_PROC_DOMAIN_DEL_IOTHREAD + ProcDomainDelIothread = 356 + // ProcDomainSetUserPassword is libvirt's REMOTE_PROC_DOMAIN_SET_USER_PASSWORD + ProcDomainSetUserPassword = 357 + // ProcDomainRename is libvirt's REMOTE_PROC_DOMAIN_RENAME + ProcDomainRename = 358 + // ProcDomainEventCallbackMigrationIteration is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION + ProcDomainEventCallbackMigrationIteration = 359 + // ProcConnectRegisterCloseCallback is libvirt's REMOTE_PROC_CONNECT_REGISTER_CLOSE_CALLBACK + ProcConnectRegisterCloseCallback = 360 + // ProcConnectUnregisterCloseCallback is libvirt's REMOTE_PROC_CONNECT_UNREGISTER_CLOSE_CALLBACK + ProcConnectUnregisterCloseCallback = 361 + // ProcConnectEventConnectionClosed is libvirt's REMOTE_PROC_CONNECT_EVENT_CONNECTION_CLOSED + ProcConnectEventConnectionClosed = 362 + // ProcDomainEventCallbackJobCompleted is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_JOB_COMPLETED + ProcDomainEventCallbackJobCompleted = 363 + // ProcDomainMigrateStartPostCopy is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY + ProcDomainMigrateStartPostCopy = 364 + // ProcDomainGetPerfEvents is libvirt's REMOTE_PROC_DOMAIN_GET_PERF_EVENTS + ProcDomainGetPerfEvents = 365 + // ProcDomainSetPerfEvents is libvirt's REMOTE_PROC_DOMAIN_SET_PERF_EVENTS + ProcDomainSetPerfEvents = 366 + // ProcDomainEventCallbackDeviceRemovalFailed is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED + ProcDomainEventCallbackDeviceRemovalFailed = 367 + // ProcConnectStoragePoolEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_REGISTER_ANY + ProcConnectStoragePoolEventRegisterAny = 368 + // ProcConnectStoragePoolEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_DEREGISTER_ANY + ProcConnectStoragePoolEventDeregisterAny = 369 + // ProcStoragePoolEventLifecycle is libvirt's REMOTE_PROC_STORAGE_POOL_EVENT_LIFECYCLE + ProcStoragePoolEventLifecycle = 370 + // ProcDomainGetGuestVcpus is libvirt's REMOTE_PROC_DOMAIN_GET_GUEST_VCPUS + ProcDomainGetGuestVcpus = 371 + // ProcDomainSetGuestVcpus is libvirt's REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS + ProcDomainSetGuestVcpus = 372 + // ProcStoragePoolEventRefresh is libvirt's REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH + ProcStoragePoolEventRefresh = 373 + // ProcConnectNodeDeviceEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_REGISTER_ANY + ProcConnectNodeDeviceEventRegisterAny = 374 + // ProcConnectNodeDeviceEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_DEREGISTER_ANY + ProcConnectNodeDeviceEventDeregisterAny = 375 + // ProcNodeDeviceEventLifecycle is libvirt's REMOTE_PROC_NODE_DEVICE_EVENT_LIFECYCLE + ProcNodeDeviceEventLifecycle = 376 + // ProcNodeDeviceEventUpdate is libvirt's REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE + ProcNodeDeviceEventUpdate = 377 + // ProcStorageVolGetInfoFlags is libvirt's REMOTE_PROC_STORAGE_VOL_GET_INFO_FLAGS + ProcStorageVolGetInfoFlags = 378 + // ProcDomainEventCallbackMetadataChange is libvirt's REMOTE_PROC_DOMAIN_EVENT_CALLBACK_METADATA_CHANGE + ProcDomainEventCallbackMetadataChange = 379 + // ProcConnectSecretEventRegisterAny is libvirt's REMOTE_PROC_CONNECT_SECRET_EVENT_REGISTER_ANY + ProcConnectSecretEventRegisterAny = 380 + // ProcConnectSecretEventDeregisterAny is libvirt's REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY + ProcConnectSecretEventDeregisterAny = 381 + // ProcSecretEventLifecycle is libvirt's REMOTE_PROC_SECRET_EVENT_LIFECYCLE + ProcSecretEventLifecycle = 382 + // ProcSecretEventValueChanged is libvirt's REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED + ProcSecretEventValueChanged = 383 + // ProcDomainSetVcpu is libvirt's REMOTE_PROC_DOMAIN_SET_VCPU + ProcDomainSetVcpu = 384 + // ProcDomainEventBlockThreshold is libvirt's REMOTE_PROC_DOMAIN_EVENT_BLOCK_THRESHOLD + ProcDomainEventBlockThreshold = 385 + // ProcDomainSetBlockThreshold is libvirt's REMOTE_PROC_DOMAIN_SET_BLOCK_THRESHOLD + ProcDomainSetBlockThreshold = 386 + // ProcDomainMigrateGetMaxDowntime is libvirt's REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_DOWNTIME + ProcDomainMigrateGetMaxDowntime = 387 + // ProcDomainManagedSaveGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_GET_XML_DESC + ProcDomainManagedSaveGetXMLDesc = 388 + // ProcDomainManagedSaveDefineXML is libvirt's REMOTE_PROC_DOMAIN_MANAGED_SAVE_DEFINE_XML + ProcDomainManagedSaveDefineXML = 389 + // ProcDomainSetLifecycleAction is libvirt's REMOTE_PROC_DOMAIN_SET_LIFECYCLE_ACTION + ProcDomainSetLifecycleAction = 390 + // ProcStoragePoolLookupByTargetPath is libvirt's REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_TARGET_PATH + ProcStoragePoolLookupByTargetPath = 391 + // ProcDomainDetachDeviceAlias is libvirt's REMOTE_PROC_DOMAIN_DETACH_DEVICE_ALIAS + ProcDomainDetachDeviceAlias = 392 + // ProcConnectCompareHypervisorCPU is libvirt's REMOTE_PROC_CONNECT_COMPARE_HYPERVISOR_CPU + ProcConnectCompareHypervisorCPU = 393 + // ProcConnectBaselineHypervisorCPU is libvirt's REMOTE_PROC_CONNECT_BASELINE_HYPERVISOR_CPU + ProcConnectBaselineHypervisorCPU = 394 + // ProcNodeGetSevInfo is libvirt's REMOTE_PROC_NODE_GET_SEV_INFO + ProcNodeGetSevInfo = 395 + // ProcDomainGetLaunchSecurityInfo is libvirt's REMOTE_PROC_DOMAIN_GET_LAUNCH_SECURITY_INFO + ProcDomainGetLaunchSecurityInfo = 396 + // ProcNwfilterBindingLookupByPortDev is libvirt's REMOTE_PROC_NWFILTER_BINDING_LOOKUP_BY_PORT_DEV + ProcNwfilterBindingLookupByPortDev = 397 + // ProcNwfilterBindingGetXMLDesc is libvirt's REMOTE_PROC_NWFILTER_BINDING_GET_XML_DESC + ProcNwfilterBindingGetXMLDesc = 398 + // ProcNwfilterBindingCreateXML is libvirt's REMOTE_PROC_NWFILTER_BINDING_CREATE_XML + ProcNwfilterBindingCreateXML = 399 + // ProcNwfilterBindingDelete is libvirt's REMOTE_PROC_NWFILTER_BINDING_DELETE + ProcNwfilterBindingDelete = 400 + // ProcConnectListAllNwfilterBindings is libvirt's REMOTE_PROC_CONNECT_LIST_ALL_NWFILTER_BINDINGS + ProcConnectListAllNwfilterBindings = 401 + // ProcDomainSetIothreadParams is libvirt's REMOTE_PROC_DOMAIN_SET_IOTHREAD_PARAMS + ProcDomainSetIothreadParams = 402 + // ProcConnectGetStoragePoolCapabilities is libvirt's REMOTE_PROC_CONNECT_GET_STORAGE_POOL_CAPABILITIES + ProcConnectGetStoragePoolCapabilities = 403 + // ProcNetworkListAllPorts is libvirt's REMOTE_PROC_NETWORK_LIST_ALL_PORTS + ProcNetworkListAllPorts = 404 + // ProcNetworkPortLookupByUUID is libvirt's REMOTE_PROC_NETWORK_PORT_LOOKUP_BY_UUID + ProcNetworkPortLookupByUUID = 405 + // ProcNetworkPortCreateXML is libvirt's REMOTE_PROC_NETWORK_PORT_CREATE_XML + ProcNetworkPortCreateXML = 406 + // ProcNetworkPortGetParameters is libvirt's REMOTE_PROC_NETWORK_PORT_GET_PARAMETERS + ProcNetworkPortGetParameters = 407 + // ProcNetworkPortSetParameters is libvirt's REMOTE_PROC_NETWORK_PORT_SET_PARAMETERS + ProcNetworkPortSetParameters = 408 + // ProcNetworkPortGetXMLDesc is libvirt's REMOTE_PROC_NETWORK_PORT_GET_XML_DESC + ProcNetworkPortGetXMLDesc = 409 + // ProcNetworkPortDelete is libvirt's REMOTE_PROC_NETWORK_PORT_DELETE + ProcNetworkPortDelete = 410 + // ProcDomainCheckpointCreateXML is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_CREATE_XML + ProcDomainCheckpointCreateXML = 411 + // ProcDomainCheckpointGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_GET_XML_DESC + ProcDomainCheckpointGetXMLDesc = 412 + // ProcDomainListAllCheckpoints is libvirt's REMOTE_PROC_DOMAIN_LIST_ALL_CHECKPOINTS + ProcDomainListAllCheckpoints = 413 + // ProcDomainCheckpointListAllChildren is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_LIST_ALL_CHILDREN + ProcDomainCheckpointListAllChildren = 414 + // ProcDomainCheckpointLookupByName is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_LOOKUP_BY_NAME + ProcDomainCheckpointLookupByName = 415 + // ProcDomainCheckpointGetParent is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_GET_PARENT + ProcDomainCheckpointGetParent = 416 + // ProcDomainCheckpointDelete is libvirt's REMOTE_PROC_DOMAIN_CHECKPOINT_DELETE + ProcDomainCheckpointDelete = 417 + // ProcDomainGetGuestInfo is libvirt's REMOTE_PROC_DOMAIN_GET_GUEST_INFO + ProcDomainGetGuestInfo = 418 + // ProcConnectSetIdentity is libvirt's REMOTE_PROC_CONNECT_SET_IDENTITY + ProcConnectSetIdentity = 419 + // ProcDomainAgentSetResponseTimeout is libvirt's REMOTE_PROC_DOMAIN_AGENT_SET_RESPONSE_TIMEOUT + ProcDomainAgentSetResponseTimeout = 420 + // ProcDomainBackupBegin is libvirt's REMOTE_PROC_DOMAIN_BACKUP_BEGIN + ProcDomainBackupBegin = 421 + // ProcDomainBackupGetXMLDesc is libvirt's REMOTE_PROC_DOMAIN_BACKUP_GET_XML_DESC + ProcDomainBackupGetXMLDesc = 422 + // ProcDomainEventMemoryFailure is libvirt's REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE + ProcDomainEventMemoryFailure = 423 + // ProcDomainAuthorizedSshKeysGet is libvirt's REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_GET + ProcDomainAuthorizedSshKeysGet = 424 + // ProcDomainAuthorizedSshKeysSet is libvirt's REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_SET + ProcDomainAuthorizedSshKeysSet = 425 + + + // From consts: + // StringMax is libvirt's REMOTE_STRING_MAX + StringMax = 4194304 + // ConnectIdentityParamsMax is libvirt's REMOTE_CONNECT_IDENTITY_PARAMS_MAX + ConnectIdentityParamsMax = 20 + // DomainListMax is libvirt's REMOTE_DOMAIN_LIST_MAX + DomainListMax = 16384 + // CpumapMax is libvirt's REMOTE_CPUMAP_MAX + CpumapMax = 2048 + // VcpuinfoMax is libvirt's REMOTE_VCPUINFO_MAX + VcpuinfoMax = 16384 + // CpumapsMax is libvirt's REMOTE_CPUMAPS_MAX + CpumapsMax = 8388608 + // IothreadInfoMax is libvirt's REMOTE_IOTHREAD_INFO_MAX + IothreadInfoMax = 16384 + // MigrateCookieMax is libvirt's REMOTE_MIGRATE_COOKIE_MAX + MigrateCookieMax = 4194304 + // NetworkListMax is libvirt's REMOTE_NETWORK_LIST_MAX + NetworkListMax = 16384 + // NetworkPortListMax is libvirt's REMOTE_NETWORK_PORT_LIST_MAX + NetworkPortListMax = 16384 + // InterfaceListMax is libvirt's REMOTE_INTERFACE_LIST_MAX + InterfaceListMax = 16384 + // StoragePoolListMax is libvirt's REMOTE_STORAGE_POOL_LIST_MAX + StoragePoolListMax = 16384 + // StorageVolListMax is libvirt's REMOTE_STORAGE_VOL_LIST_MAX + StorageVolListMax = 16384 + // NodeDeviceListMax is libvirt's REMOTE_NODE_DEVICE_LIST_MAX + NodeDeviceListMax = 65536 + // NodeDeviceCapsListMax is libvirt's REMOTE_NODE_DEVICE_CAPS_LIST_MAX + NodeDeviceCapsListMax = 65536 + // NwfilterListMax is libvirt's REMOTE_NWFILTER_LIST_MAX + NwfilterListMax = 16384 + // NwfilterBindingListMax is libvirt's REMOTE_NWFILTER_BINDING_LIST_MAX + NwfilterBindingListMax = 16384 + // DomainSchedulerParametersMax is libvirt's REMOTE_DOMAIN_SCHEDULER_PARAMETERS_MAX + DomainSchedulerParametersMax = 16 + // DomainBlkioParametersMax is libvirt's REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX + DomainBlkioParametersMax = 16 + // DomainMemoryParametersMax is libvirt's REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX + DomainMemoryParametersMax = 16 + // DomainBlockIOTuneParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_IO_TUNE_PARAMETERS_MAX + DomainBlockIOTuneParametersMax = 32 + // DomainNumaParametersMax is libvirt's REMOTE_DOMAIN_NUMA_PARAMETERS_MAX + DomainNumaParametersMax = 16 + // DomainPerfEventsMax is libvirt's REMOTE_DOMAIN_PERF_EVENTS_MAX + DomainPerfEventsMax = 64 + // DomainBlockCopyParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_COPY_PARAMETERS_MAX + DomainBlockCopyParametersMax = 16 + // NodeCPUStatsMax is libvirt's REMOTE_NODE_CPU_STATS_MAX + NodeCPUStatsMax = 16 + // NodeMemoryStatsMax is libvirt's REMOTE_NODE_MEMORY_STATS_MAX + NodeMemoryStatsMax = 16 + // DomainBlockStatsParametersMax is libvirt's REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX + DomainBlockStatsParametersMax = 16 + // NodeMaxCells is libvirt's REMOTE_NODE_MAX_CELLS + NodeMaxCells = 1024 + // AuthSaslDataMax is libvirt's REMOTE_AUTH_SASL_DATA_MAX + AuthSaslDataMax = 65536 + // AuthTypeListMax is libvirt's REMOTE_AUTH_TYPE_LIST_MAX + AuthTypeListMax = 20 + // DomainMemoryStatsMax is libvirt's REMOTE_DOMAIN_MEMORY_STATS_MAX + DomainMemoryStatsMax = 1024 + // DomainCheckpointListMax is libvirt's REMOTE_DOMAIN_CHECKPOINT_LIST_MAX + DomainCheckpointListMax = 16384 + // DomainSnapshotListMax is libvirt's REMOTE_DOMAIN_SNAPSHOT_LIST_MAX + DomainSnapshotListMax = 16384 + // DomainBlockPeekBufferMax is libvirt's REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX + DomainBlockPeekBufferMax = 4194304 + // DomainMemoryPeekBufferMax is libvirt's REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX + DomainMemoryPeekBufferMax = 4194304 + // SecurityLabelListMax is libvirt's REMOTE_SECURITY_LABEL_LIST_MAX + SecurityLabelListMax = 64 + // SecretValueMax is libvirt's REMOTE_SECRET_VALUE_MAX + SecretValueMax = 65536 + // SecretListMax is libvirt's REMOTE_SECRET_LIST_MAX + SecretListMax = 16384 + // CPUBaselineMax is libvirt's REMOTE_CPU_BASELINE_MAX + CPUBaselineMax = 256 + // DomainSendKeyMax is libvirt's REMOTE_DOMAIN_SEND_KEY_MAX + DomainSendKeyMax = 16 + // DomainInterfaceParametersMax is libvirt's REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX + DomainInterfaceParametersMax = 16 + // DomainGetCPUStatsNcpusMax is libvirt's REMOTE_DOMAIN_GET_CPU_STATS_NCPUS_MAX + DomainGetCPUStatsNcpusMax = 128 + // DomainGetCPUStatsMax is libvirt's REMOTE_DOMAIN_GET_CPU_STATS_MAX + DomainGetCPUStatsMax = 2048 + // DomainDiskErrorsMax is libvirt's REMOTE_DOMAIN_DISK_ERRORS_MAX + DomainDiskErrorsMax = 256 + // NodeMemoryParametersMax is libvirt's REMOTE_NODE_MEMORY_PARAMETERS_MAX + NodeMemoryParametersMax = 64 + // DomainMigrateParamListMax is libvirt's REMOTE_DOMAIN_MIGRATE_PARAM_LIST_MAX + DomainMigrateParamListMax = 64 + // DomainJobStatsMax is libvirt's REMOTE_DOMAIN_JOB_STATS_MAX + DomainJobStatsMax = 64 + // ConnectCPUModelsMax is libvirt's REMOTE_CONNECT_CPU_MODELS_MAX + ConnectCPUModelsMax = 8192 + // DomainFsfreezeMountpointsMax is libvirt's REMOTE_DOMAIN_FSFREEZE_MOUNTPOINTS_MAX + DomainFsfreezeMountpointsMax = 256 + // NetworkDhcpLeasesMax is libvirt's REMOTE_NETWORK_DHCP_LEASES_MAX + NetworkDhcpLeasesMax = 65536 + // ConnectGetAllDomainStatsMax is libvirt's REMOTE_CONNECT_GET_ALL_DOMAIN_STATS_MAX + ConnectGetAllDomainStatsMax = 262144 + // DomainEventTunableMax is libvirt's REMOTE_DOMAIN_EVENT_TUNABLE_MAX + DomainEventTunableMax = 2048 + // DomainFsinfoMax is libvirt's REMOTE_DOMAIN_FSINFO_MAX + DomainFsinfoMax = 256 + // DomainFsinfoDisksMax is libvirt's REMOTE_DOMAIN_FSINFO_DISKS_MAX + DomainFsinfoDisksMax = 256 + // DomainInterfaceMax is libvirt's REMOTE_DOMAIN_INTERFACE_MAX + DomainInterfaceMax = 2048 + // DomainIPAddrMax is libvirt's REMOTE_DOMAIN_IP_ADDR_MAX + DomainIPAddrMax = 2048 + // DomainGuestVcpuParamsMax is libvirt's REMOTE_DOMAIN_GUEST_VCPU_PARAMS_MAX + DomainGuestVcpuParamsMax = 64 + // DomainIothreadParamsMax is libvirt's REMOTE_DOMAIN_IOTHREAD_PARAMS_MAX + DomainIothreadParamsMax = 64 + // NodeSevInfoMax is libvirt's REMOTE_NODE_SEV_INFO_MAX + NodeSevInfoMax = 64 + // DomainLaunchSecurityInfoParamsMax is libvirt's REMOTE_DOMAIN_LAUNCH_SECURITY_INFO_PARAMS_MAX + DomainLaunchSecurityInfoParamsMax = 64 + // DomainGuestInfoParamsMax is libvirt's REMOTE_DOMAIN_GUEST_INFO_PARAMS_MAX + DomainGuestInfoParamsMax = 2048 + // NetworkPortParametersMax is libvirt's REMOTE_NETWORK_PORT_PARAMETERS_MAX + NetworkPortParametersMax = 16 + // DomainAuthorizedSshKeysMax is libvirt's REMOTE_DOMAIN_AUTHORIZED_SSH_KEYS_MAX + DomainAuthorizedSshKeysMax = 2048 + // DomainEventGraphicsIdentityMax is libvirt's REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX + DomainEventGraphicsIdentityMax = 20 + // Program is libvirt's REMOTE_PROGRAM + Program = 0x20008086 + // ProtocolVersion is libvirt's REMOTE_PROTOCOL_VERSION + ProtocolVersion = 1 +) diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go b/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go new file mode 100644 index 000000000..67a1885b9 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/event/event.go @@ -0,0 +1,20 @@ +// Copyright 2020 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package event + +// Event represents an internal Event. +type Event interface { + GetCallbackID() int32 +} diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go b/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go new file mode 100644 index 000000000..b14e41b64 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/event/stream.go @@ -0,0 +1,145 @@ +// Copyright 2020 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package event + +import "context" + +// Stream is an unbounded buffered event channel. The implementation +// consists of a pair of unbuffered channels and a goroutine to manage them. +// Client behavior will not cause incoming events to block. +type Stream struct { + // Program specifies the source of the events - libvirt or QEMU. + Program uint32 + + // CallbackID is returned by the event registration call. + CallbackID int32 + + // manage unbounded channel behavior. + queue []Event + in, out chan Event + + // terminates processing + shutdown context.CancelFunc +} + +// Recv returns the next available event from the Stream's queue. +func (s *Stream) Recv() chan Event { + return s.out +} + +// Push appends a new event to the queue. +func (s *Stream) Push(e Event) { + s.in <- e +} + +// Shutdown gracefully terminates Stream processing, releasing all +// internal resources. Events which have not yet been received by the client +// will be dropped. Subsequent calls to Shutdown() are idempotent. +func (s *Stream) Shutdown() { + if s.shutdown != nil { + s.shutdown() + } +} + +// start starts the event processing loop, which will continue to run until +// terminated by the returned context.CancelFunc. Starting a previously started +// Stream is an idempotent operation. +func (s *Stream) start() context.CancelFunc { + ctx, cancel := context.WithCancel(context.Background()) + + go s.process(ctx) + + return cancel +} + +// process manages an Stream's lifecycle until canceled by the provided +// context. Incoming events are appended to a queue which is then relayed to +// the a listening client. New events pushed onto the queue will not block due +// to client behavior. +func (s *Stream) process(ctx context.Context) { + defer func() { + close(s.in) + close(s.out) + }() + + for { + // informs send() to stop trying + nctx, next := context.WithCancel(ctx) + defer next() + + select { + // new event received, append to queue + case e := <-s.in: + s.queue = append(s.queue, e) + + // client recieved an event, pop from queue + case <-s.send(nctx): + if len(s.queue) > 1 { + s.queue = s.queue[1:] + } else { + s.queue = []Event{} + } + + // shutdown requested + case <-ctx.Done(): + return + + } + + next() + } +} + +// send returns a channel which blocks until either the first item on the queue +// (if existing) is sent to the client, or the provided context is canceled. +// The stream's queue is never modified. +func (s *Stream) send(ctx context.Context) <-chan struct{} { + ch := make(chan struct{}) + + go func() { + defer close(ch) + + // do nothing and block if the queue is empty + if len(s.queue) == 0 { + <-ctx.Done() + return + } + + // otherwise, attempt to send the event + select { + case s.out <- s.queue[0]: + case <-ctx.Done(): + } + }() + + return ch +} + +// NewStream configures a new Event Stream. Incoming events are appended to a +// queue, which is then relayed to the listening client. Client behavior will +// not cause incoming events to block. It is the responsibility of the caller +// to terminate the Stream via Shutdown() when no longer in use. +func NewStream(program uint32, cbID int32) *Stream { + ic := &Stream{ + Program: program, + CallbackID: cbID, + in: make(chan Event), + out: make(chan Event), + } + + ic.shutdown = ic.start() + + return ic +} diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE new file mode 100644 index 000000000..0cc3543ce --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2012-2014 Dave Collins <dave@davec.name> + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go new file mode 100644 index 000000000..7f33f7d32 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/decode.go @@ -0,0 +1,896 @@ +/* + * Copyright (c) 2012-2014 Dave Collins <dave@davec.name> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package xdr + +import ( + "fmt" + "io" + "math" + "reflect" + "time" +) + +var ( + errMaxSlice = "data exceeds max slice limit" + errIODecode = "%s while decoding %d bytes" +) + +/* +Unmarshal parses XDR-encoded data into the value pointed to by v reading from +reader r and returning the total number of bytes read. An addressable pointer +must be provided since Unmarshal needs to both store the result of the decode as +well as obtain target type information. Unmarhsal traverses v recursively and +automatically indirects pointers through arbitrary depth, allocating them as +necessary, to decode the data into the underlying value pointed to. + +Unmarshal uses reflection to determine the type of the concrete value contained +by v and performs a mapping of underlying XDR types to Go types as follows: + + Go Type <- XDR Type + -------------------- + int8, int16, int32, int <- XDR Integer + uint8, uint16, uint32, uint <- XDR Unsigned Integer + int64 <- XDR Hyper Integer + uint64 <- XDR Unsigned Hyper Integer + bool <- XDR Boolean + float32 <- XDR Floating-Point + float64 <- XDR Double-Precision Floating-Point + string <- XDR String + byte <- XDR Integer + []byte <- XDR Variable-Length Opaque Data + [#]byte <- XDR Fixed-Length Opaque Data + []<type> <- XDR Variable-Length Array + [#]<type> <- XDR Fixed-Length Array + struct <- XDR Structure + map <- XDR Variable-Length Array of two-element XDR Structures + time.Time <- XDR String encoded with RFC3339 nanosecond precision + +Notes and Limitations: + + * Automatic unmarshalling of variable and fixed-length arrays of uint8s + requires a special struct tag `xdropaque:"false"` since byte slices + and byte arrays are assumed to be opaque data and byte is a Go alias + for uint8 thus indistinguishable under reflection + * Cyclic data structures are not supported and will result in infinite + loops + +If any issues are encountered during the unmarshalling process, an +UnmarshalError is returned with a human readable description as well as +an ErrorCode value for further inspection from sophisticated callers. Some +potential issues are unsupported Go types, attempting to decode a value which is +too large to fit into a specified Go type, and exceeding max slice limitations. +*/ +func Unmarshal(r io.Reader, v interface{}) (int, error) { + d := Decoder{r: r} + return d.Decode(v) +} + +// UnmarshalLimited is identical to Unmarshal but it sets maxReadSize in order +// to cap reads. +func UnmarshalLimited(r io.Reader, v interface{}, maxSize uint) (int, error) { + d := Decoder{r: r, maxReadSize: maxSize} + return d.Decode(v) +} + +// TypeDecoder lets a caller provide a custom decode routine for a custom type. +type TypeDecoder interface { + Decode(*Decoder, reflect.Value) (int, error) +} + +// A Decoder wraps an io.Reader that is expected to provide an XDR-encoded byte +// stream and provides several exposed methods to manually decode various XDR +// primitives without relying on reflection. The NewDecoder function can be +// used to get a new Decoder directly. +// +// Typically, Unmarshal should be used instead of manual decoding. A Decoder +// is exposed so it is possible to perform manual decoding should it be +// necessary in complex scenarios where automatic reflection-based decoding +// won't work. +type Decoder struct { + r io.Reader + + // maxReadSize is the default maximum bytes an element can contain. 0 + // is unlimited and provides backwards compatability. Setting it to a + // non-zero value caps reads. + maxReadSize uint + + // customTypes is a map allowing the caller to provide decoder routines for + // custom types known only to itself. + customTypes map[string]TypeDecoder +} + +// DecodeInt treats the next 4 bytes as an XDR encoded integer and returns the +// result as an int32 along with the number of bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.1 - Integer +// 32-bit big-endian signed integer in range [-2147483648, 2147483647] +func (d *Decoder) DecodeInt() (int32, int, error) { + var buf [4]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 4) + err := unmarshalError("DecodeInt", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + rv := int32(buf[3]) | int32(buf[2])<<8 | + int32(buf[1])<<16 | int32(buf[0])<<24 + return rv, n, nil +} + +// DecodeUint treats the next 4 bytes as an XDR encoded unsigned integer and +// returns the result as a uint32 along with the number of bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.2 - Unsigned Integer +// 32-bit big-endian unsigned integer in range [0, 4294967295] +func (d *Decoder) DecodeUint() (uint32, int, error) { + var buf [4]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 4) + err := unmarshalError("DecodeUint", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + rv := uint32(buf[3]) | uint32(buf[2])<<8 | + uint32(buf[1])<<16 | uint32(buf[0])<<24 + return rv, n, nil +} + +// DecodeEnum treats the next 4 bytes as an XDR encoded enumeration value and +// returns the result as an int32 after verifying that the value is in the +// provided map of valid values. It also returns the number of bytes actually +// read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining or +// the parsed enumeration value is not one of the provided valid values. +// +// Reference: +// RFC Section 4.3 - Enumeration +// Represented as an XDR encoded signed integer +func (d *Decoder) DecodeEnum(validEnums map[int32]bool) (int32, int, error) { + val, n, err := d.DecodeInt() + if err != nil { + return 0, n, err + } + + if !validEnums[val] { + err := unmarshalError("DecodeEnum", ErrBadEnumValue, + "invalid enum", val, nil) + return 0, n, err + } + return val, n, nil +} + +// DecodeBool treats the next 4 bytes as an XDR encoded boolean value and +// returns the result as a bool along with the number of bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining or +// the parsed value is not a 0 or 1. +// +// Reference: +// RFC Section 4.4 - Boolean +// Represented as an XDR encoded enumeration where 0 is false and 1 is true +func (d *Decoder) DecodeBool() (bool, int, error) { + val, n, err := d.DecodeInt() + if err != nil { + return false, n, err + } + switch val { + case 0: + return false, n, nil + case 1: + return true, n, nil + } + + err = unmarshalError("DecodeBool", ErrBadEnumValue, "bool not 0 or 1", + val, nil) + return false, n, err +} + +// DecodeHyper treats the next 8 bytes as an XDR encoded hyper value and +// returns the result as an int64 along with the number of bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.5 - Hyper Integer +// 64-bit big-endian signed integer in range [-9223372036854775808, 9223372036854775807] +func (d *Decoder) DecodeHyper() (int64, int, error) { + var buf [8]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 8) + err := unmarshalError("DecodeHyper", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + rv := int64(buf[7]) | int64(buf[6])<<8 | + int64(buf[5])<<16 | int64(buf[4])<<24 | + int64(buf[3])<<32 | int64(buf[2])<<40 | + int64(buf[1])<<48 | int64(buf[0])<<56 + return rv, n, err +} + +// DecodeUhyper treats the next 8 bytes as an XDR encoded unsigned hyper value +// and returns the result as a uint64 along with the number of bytes actually +// read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.5 - Unsigned Hyper Integer +// 64-bit big-endian unsigned integer in range [0, 18446744073709551615] +func (d *Decoder) DecodeUhyper() (uint64, int, error) { + var buf [8]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 8) + err := unmarshalError("DecodeUhyper", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + rv := uint64(buf[7]) | uint64(buf[6])<<8 | + uint64(buf[5])<<16 | uint64(buf[4])<<24 | + uint64(buf[3])<<32 | uint64(buf[2])<<40 | + uint64(buf[1])<<48 | uint64(buf[0])<<56 + return rv, n, nil +} + +// DecodeFloat treats the next 4 bytes as an XDR encoded floating point and +// returns the result as a float32 along with the number of bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.6 - Floating Point +// 32-bit single-precision IEEE 754 floating point +func (d *Decoder) DecodeFloat() (float32, int, error) { + var buf [4]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 4) + err := unmarshalError("DecodeFloat", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + val := uint32(buf[3]) | uint32(buf[2])<<8 | + uint32(buf[1])<<16 | uint32(buf[0])<<24 + return math.Float32frombits(val), n, nil +} + +// DecodeDouble treats the next 8 bytes as an XDR encoded double-precision +// floating point and returns the result as a float64 along with the number of +// bytes actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining. +// +// Reference: +// RFC Section 4.7 - Double-Precision Floating Point +// 64-bit double-precision IEEE 754 floating point +func (d *Decoder) DecodeDouble() (float64, int, error) { + var buf [8]byte + n, err := io.ReadFull(d.r, buf[:]) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), 8) + err := unmarshalError("DecodeDouble", ErrIO, msg, buf[:n], err) + return 0, n, err + } + + val := uint64(buf[7]) | uint64(buf[6])<<8 | + uint64(buf[5])<<16 | uint64(buf[4])<<24 | + uint64(buf[3])<<32 | uint64(buf[2])<<40 | + uint64(buf[1])<<48 | uint64(buf[0])<<56 + return math.Float64frombits(val), n, nil +} + +// RFC Section 4.8 - Quadruple-Precision Floating Point +// 128-bit quadruple-precision floating point +// Not Implemented + +// DecodeFixedOpaque treats the next 'size' bytes as XDR encoded opaque data and +// returns the result as a byte slice along with the number of bytes actually +// read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining to +// satisfy the passed size, including the necessary padding to make it a +// multiple of 4. +// +// Reference: +// RFC Section 4.9 - Fixed-Length Opaque Data +// Fixed-length uninterpreted data zero-padded to a multiple of four +func (d *Decoder) DecodeFixedOpaque(size int32) ([]byte, int, error) { + // Nothing to do if size is 0. + if size == 0 { + return nil, 0, nil + } + + pad := (4 - (size % 4)) % 4 + paddedSize := size + pad + if uint(paddedSize) > uint(math.MaxInt32) { + err := unmarshalError("DecodeFixedOpaque", ErrOverflow, + errMaxSlice, paddedSize, nil) + return nil, 0, err + } + + buf := make([]byte, paddedSize) + n, err := io.ReadFull(d.r, buf) + if err != nil { + msg := fmt.Sprintf(errIODecode, err.Error(), paddedSize) + err := unmarshalError("DecodeFixedOpaque", ErrIO, msg, buf[:n], + err) + return nil, n, err + } + return buf[0:size], n, nil +} + +// DecodeOpaque treats the next bytes as variable length XDR encoded opaque +// data and returns the result as a byte slice along with the number of bytes +// actually read. +// +// An UnmarshalError is returned if there are insufficient bytes remaining or +// the opaque data is larger than the max length of a Go slice. +// +// Reference: +// RFC Section 4.10 - Variable-Length Opaque Data +// Unsigned integer length followed by fixed opaque data of that length +func (d *Decoder) DecodeOpaque() ([]byte, int, error) { + dataLen, n, err := d.DecodeUint() + if err != nil { + return nil, n, err + } + if uint(dataLen) > uint(math.MaxInt32) || + (d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) { + err := unmarshalError("DecodeOpaque", ErrOverflow, errMaxSlice, + dataLen, nil) + return nil, n, err + } + + rv, n2, err := d.DecodeFixedOpaque(int32(dataLen)) + n += n2 + if err != nil { + return nil, n, err + } + return rv, n, nil +} + +// DecodeString treats the next bytes as a variable length XDR encoded string +// and returns the result as a string along with the number of bytes actually +// read. Character encoding is assumed to be UTF-8 and therefore ASCII +// compatible. If the underlying character encoding is not compatibile with +// this assumption, the data can instead be read as variable-length opaque data +// (DecodeOpaque) and manually converted as needed. +// +// An UnmarshalError is returned if there are insufficient bytes remaining or +// the string data is larger than the max length of a Go slice. +// +// Reference: +// RFC Section 4.11 - String +// Unsigned integer length followed by bytes zero-padded to a multiple of +// four +func (d *Decoder) DecodeString() (string, int, error) { + dataLen, n, err := d.DecodeUint() + if err != nil { + return "", n, err + } + if uint(dataLen) > uint(math.MaxInt32) || + (d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) { + err = unmarshalError("DecodeString", ErrOverflow, errMaxSlice, + dataLen, nil) + return "", n, err + } + + opaque, n2, err := d.DecodeFixedOpaque(int32(dataLen)) + n += n2 + if err != nil { + return "", n, err + } + return string(opaque), n, nil +} + +// decodeFixedArray treats the next bytes as a series of XDR encoded elements +// of the same type as the array represented by the reflection value and decodes +// each element into the passed array. The ignoreOpaque flag controls whether +// or not uint8 (byte) elements should be decoded individually or as a fixed +// sequence of opaque data. It returns the the number of bytes actually read. +// +// An UnmarshalError is returned if any issues are encountered while decoding +// the array elements. +// +// Reference: +// RFC Section 4.12 - Fixed-Length Array +// Individually XDR encoded array elements +func (d *Decoder) decodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) { + // Treat [#]byte (byte is alias for uint8) as opaque data unless + // ignored. + if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 { + data, n, err := d.DecodeFixedOpaque(int32(v.Len())) + if err != nil { + return n, err + } + reflect.Copy(v, reflect.ValueOf(data)) + return n, nil + } + + // Decode each array element. + var n int + for i := 0; i < v.Len(); i++ { + n2, err := d.decode(v.Index(i)) + n += n2 + if err != nil { + return n, err + } + } + return n, nil +} + +// decodeArray treats the next bytes as a variable length series of XDR encoded +// elements of the same type as the array represented by the reflection value. +// The number of elements is obtained by first decoding the unsigned integer +// element count. Then each element is decoded into the passed array. The +// ignoreOpaque flag controls whether or not uint8 (byte) elements should be +// decoded individually or as a variable sequence of opaque data. It returns +// the number of bytes actually read. +// +// An UnmarshalError is returned if any issues are encountered while decoding +// the array elements. +// +// Reference: +// RFC Section 4.13 - Variable-Length Array +// Unsigned integer length followed by individually XDR encoded array +// elements +func (d *Decoder) decodeArray(v reflect.Value, ignoreOpaque bool) (int, error) { + dataLen, n, err := d.DecodeUint() + if err != nil { + return n, err + } + if uint(dataLen) > uint(math.MaxInt32) || + (d.maxReadSize != 0 && uint(dataLen) > d.maxReadSize) { + err := unmarshalError("decodeArray", ErrOverflow, errMaxSlice, + dataLen, nil) + return n, err + } + + // Allocate storage for the slice elements (the underlying array) if + // existing slice does not have enough capacity. + sliceLen := int(dataLen) + if v.Cap() < sliceLen { + v.Set(reflect.MakeSlice(v.Type(), sliceLen, sliceLen)) + } + if v.Len() < sliceLen { + v.SetLen(sliceLen) + } + + // Treat []byte (byte is alias for uint8) as opaque data unless ignored. + if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 { + data, n2, err := d.DecodeFixedOpaque(int32(sliceLen)) + n += n2 + if err != nil { + return n, err + } + v.SetBytes(data) + return n, nil + } + + // Decode each slice element. + for i := 0; i < sliceLen; i++ { + n2, err := d.decode(v.Index(i)) + n += n2 + if err != nil { + return n, err + } + } + return n, nil +} + +// decodeStruct treats the next bytes as a series of XDR encoded elements +// of the same type as the exported fields of the struct represented by the +// passed reflection value. Pointers are automatically indirected and +// allocated as necessary. It returns the the number of bytes actually read. +// +// An UnmarshalError is returned if any issues are encountered while decoding +// the elements. +// +// Reference: +// RFC Section 4.14 - Structure +// XDR encoded elements in the order of their declaration in the struct +func (d *Decoder) decodeStruct(v reflect.Value) (int, error) { + var n int + vt := v.Type() + for i := 0; i < v.NumField(); i++ { + // Skip unexported fields. + vtf := vt.Field(i) + if vtf.PkgPath != "" { + continue + } + + // Indirect through pointers allocating them as needed and + // ensure the field is settable. + vf := v.Field(i) + vf, err := d.indirect(vf) + if err != nil { + return n, err + } + if !vf.CanSet() { + msg := fmt.Sprintf("can't decode to unsettable '%v'", + vf.Type().String()) + err := unmarshalError("decodeStruct", ErrNotSettable, + msg, nil, nil) + return n, err + } + + // Handle non-opaque data to []uint8 and [#]uint8 based on + // struct tag. + tag := vtf.Tag.Get("xdropaque") + if tag == "false" { + switch vf.Kind() { + case reflect.Slice: + n2, err := d.decodeArray(vf, true) + n += n2 + if err != nil { + return n, err + } + continue + + case reflect.Array: + n2, err := d.decodeFixedArray(vf, true) + n += n2 + if err != nil { + return n, err + } + continue + } + } + + // Decode each struct field. + n2, err := d.decode(vf) + n += n2 + if err != nil { + return n, err + } + } + + return n, nil +} + +// RFC Section 4.15 - Discriminated Union +// RFC Section 4.16 - Void +// RFC Section 4.17 - Constant +// RFC Section 4.18 - Typedef +// RFC Section 4.19 - Optional data +// RFC Sections 4.15 though 4.19 only apply to the data specification language +// which is not implemented by this package. In the case of discriminated +// unions, struct tags are used to perform a similar function. + +// decodeMap treats the next bytes as an XDR encoded variable array of 2-element +// structures whose fields are of the same type as the map keys and elements +// represented by the passed reflection value. Pointers are automatically +// indirected and allocated as necessary. It returns the the number of bytes +// actually read. +// +// An UnmarshalError is returned if any issues are encountered while decoding +// the elements. +func (d *Decoder) decodeMap(v reflect.Value) (int, error) { + dataLen, n, err := d.DecodeUint() + if err != nil { + return n, err + } + + // Allocate storage for the underlying map if needed. + vt := v.Type() + if v.IsNil() { + v.Set(reflect.MakeMap(vt)) + } + + // Decode each key and value according to their type. + keyType := vt.Key() + elemType := vt.Elem() + for i := uint32(0); i < dataLen; i++ { + key := reflect.New(keyType).Elem() + n2, err := d.decode(key) + n += n2 + if err != nil { + return n, err + } + + val := reflect.New(elemType).Elem() + n2, err = d.decode(val) + n += n2 + if err != nil { + return n, err + } + v.SetMapIndex(key, val) + } + return n, nil +} + +// decodeInterface examines the interface represented by the passed reflection +// value to detect whether it is an interface that can be decoded into and +// if it is, extracts the underlying value to pass back into the decode function +// for decoding according to its type. It returns the the number of bytes +// actually read. +// +// An UnmarshalError is returned if any issues are encountered while decoding +// the interface. +func (d *Decoder) decodeInterface(v reflect.Value) (int, error) { + if v.IsNil() || !v.CanInterface() { + msg := fmt.Sprintf("can't decode to nil interface") + err := unmarshalError("decodeInterface", ErrNilInterface, msg, + nil, nil) + return 0, err + } + + // Extract underlying value from the interface and indirect through + // pointers allocating them as needed. + ve := reflect.ValueOf(v.Interface()) + ve, err := d.indirect(ve) + if err != nil { + return 0, err + } + if !ve.CanSet() { + msg := fmt.Sprintf("can't decode to unsettable '%v'", + ve.Type().String()) + err := unmarshalError("decodeInterface", ErrNotSettable, msg, + nil, nil) + return 0, err + } + return d.decode(ve) +} + +// decode is the main workhorse for unmarshalling via reflection. It uses +// the passed reflection value to choose the XDR primitives to decode from +// the encapsulated reader. It is a recursive function, +// so cyclic data structures are not supported and will result in an infinite +// loop. It returns the the number of bytes actually read. +func (d *Decoder) decode(v reflect.Value) (int, error) { + if !v.IsValid() { + msg := fmt.Sprintf("type '%s' is not valid", v.Kind().String()) + err := unmarshalError("decode", ErrUnsupportedType, msg, nil, nil) + return 0, err + } + + // Indirect through pointers allocating them as needed. + ve, err := d.indirect(v) + if err != nil { + return 0, err + } + + // Handle time.Time values by decoding them as an RFC3339 formatted + // string with nanosecond precision. Check the type string rather + // than doing a full blown conversion to interface and type assertion + // since checking a string is much quicker. + switch ve.Type().String() { + case "time.Time": + // Read the value as a string and parse it. + timeString, n, err := d.DecodeString() + if err != nil { + return n, err + } + ttv, err := time.Parse(time.RFC3339, timeString) + if err != nil { + err := unmarshalError("decode", ErrParseTime, + err.Error(), timeString, err) + return n, err + } + ve.Set(reflect.ValueOf(ttv)) + return n, nil + } + // If this type is in our custom types map, call the decode routine set up + // for it. + if dt, ok := d.customTypes[ve.Type().String()]; ok { + return dt.Decode(d, v) + } + + // Handle native Go types. + switch ve.Kind() { + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int: + i, n, err := d.DecodeInt() + if err != nil { + return n, err + } + if ve.OverflowInt(int64(i)) { + msg := fmt.Sprintf("signed integer too large to fit '%s'", + ve.Kind().String()) + err = unmarshalError("decode", ErrOverflow, msg, i, nil) + return n, err + } + ve.SetInt(int64(i)) + return n, nil + + case reflect.Int64: + i, n, err := d.DecodeHyper() + if err != nil { + return n, err + } + ve.SetInt(i) + return n, nil + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint: + ui, n, err := d.DecodeUint() + if err != nil { + return n, err + } + if ve.OverflowUint(uint64(ui)) { + msg := fmt.Sprintf("unsigned integer too large to fit '%s'", + ve.Kind().String()) + err = unmarshalError("decode", ErrOverflow, msg, ui, nil) + return n, err + } + ve.SetUint(uint64(ui)) + return n, nil + + case reflect.Uint64: + ui, n, err := d.DecodeUhyper() + if err != nil { + return n, err + } + ve.SetUint(ui) + return n, nil + + case reflect.Bool: + b, n, err := d.DecodeBool() + if err != nil { + return n, err + } + ve.SetBool(b) + return n, nil + + case reflect.Float32: + f, n, err := d.DecodeFloat() + if err != nil { + return n, err + } + ve.SetFloat(float64(f)) + return n, nil + + case reflect.Float64: + f, n, err := d.DecodeDouble() + if err != nil { + return n, err + } + ve.SetFloat(f) + return n, nil + + case reflect.String: + s, n, err := d.DecodeString() + if err != nil { + return n, err + } + ve.SetString(s) + return n, nil + + case reflect.Array: + n, err := d.decodeFixedArray(ve, false) + if err != nil { + return n, err + } + return n, nil + + case reflect.Slice: + n, err := d.decodeArray(ve, false) + if err != nil { + return n, err + } + return n, nil + + case reflect.Struct: + n, err := d.decodeStruct(ve) + if err != nil { + return n, err + } + return n, nil + + case reflect.Map: + n, err := d.decodeMap(ve) + if err != nil { + return n, err + } + return n, nil + + case reflect.Interface: + n, err := d.decodeInterface(ve) + if err != nil { + return n, err + } + return n, nil + } + + // The only unhandled types left are unsupported. At the time of this + // writing the only remaining unsupported types that exist are + // reflect.Uintptr and reflect.UnsafePointer. + msg := fmt.Sprintf("unsupported Go type '%s'", ve.Kind().String()) + err = unmarshalError("decode", ErrUnsupportedType, msg, nil, nil) + return 0, err +} + +// indirect dereferences pointers allocating them as needed until it reaches +// a non-pointer. This allows transparent decoding through arbitrary levels +// of indirection. +func (d *Decoder) indirect(v reflect.Value) (reflect.Value, error) { + rv := v + for rv.Kind() == reflect.Ptr { + // Allocate pointer if needed. + isNil := rv.IsNil() + if isNil && !rv.CanSet() { + msg := fmt.Sprintf("unable to allocate pointer for '%v'", + rv.Type().String()) + err := unmarshalError("indirect", ErrNotSettable, msg, + nil, nil) + return rv, err + } + if isNil { + rv.Set(reflect.New(rv.Type().Elem())) + } + rv = rv.Elem() + } + return rv, nil +} + +// Decode operates identically to the Unmarshal function with the exception of +// using the reader associated with the Decoder as the source of XDR-encoded +// data instead of a user-supplied reader. See the Unmarhsal documentation for +// specifics. +func (d *Decoder) Decode(v interface{}) (int, error) { + if v == nil { + msg := "can't unmarshal to nil interface" + return 0, unmarshalError("Unmarshal", ErrNilInterface, msg, nil, + nil) + } + + vv := reflect.ValueOf(v) + if vv.Kind() != reflect.Ptr { + msg := fmt.Sprintf("can't unmarshal to non-pointer '%v' - use "+ + "& operator", vv.Type().String()) + err := unmarshalError("Unmarshal", ErrBadArguments, msg, nil, nil) + return 0, err + } + if vv.IsNil() && !vv.CanSet() { + msg := fmt.Sprintf("can't unmarshal to unsettable '%v' - use "+ + "& operator", vv.Type().String()) + err := unmarshalError("Unmarshal", ErrNotSettable, msg, nil, nil) + return 0, err + } + + return d.decode(vv) +} + +// NewDecoder returns a Decoder that can be used to manually decode XDR data +// from a provided reader. Typically, Unmarshal should be used instead of +// manually creating a Decoder. +func NewDecoder(r io.Reader) *Decoder { + return &Decoder{r: r} +} + +// NewDecoderLimited is identical to NewDecoder but it sets maxReadSize in +// order to cap reads. +func NewDecoderLimited(r io.Reader, maxSize uint) *Decoder { + return &Decoder{r: r, maxReadSize: maxSize} +} + +// NewDecoderCustomTypes returns a decoder with support for custom types known +// to the caller. The second parameter is a map of the type name to the decoder +// routine. When the decoder finds a type matching one of the entries in the map +// it will call the custom routine for that type. +func NewDecoderCustomTypes(r io.Reader, maxSize uint, ct map[string]TypeDecoder) *Decoder { + return &Decoder{r: r, maxReadSize: maxSize, customTypes: ct} +} diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go new file mode 100644 index 000000000..8823d62f3 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/doc.go @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2012-2014 Dave Collins <dave@davec.name> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* +Package xdr implements the data representation portion of the External Data +Representation (XDR) standard protocol as specified in RFC 4506 (obsoletes +RFC 1832 and RFC 1014). + +The XDR RFC defines both a data specification language and a data +representation standard. This package implements methods to encode and decode +XDR data per the data representation standard with the exception of 128-bit +quadruple-precision floating points. It does not currently implement parsing of +the data specification language. In other words, the ability to automatically +generate Go code by parsing an XDR data specification file (typically .x +extension) is not supported. In practice, this limitation of the package is +fairly minor since it is largely unnecessary due to the reflection capabilities +of Go as described below. + +This package provides two approaches for encoding and decoding XDR data: + + 1) Marshal/Unmarshal functions which automatically map between XDR and Go types + 2) Individual Encoder/Decoder objects to manually work with XDR primitives + +For the Marshal/Unmarshal functions, Go reflection capabilities are used to +choose the type of the underlying XDR data based upon the Go type to encode or +the target Go type to decode into. A description of how each type is mapped is +provided below, however one important type worth reviewing is Go structs. In +the case of structs, each exported field (first letter capitalized) is reflected +and mapped in order. As a result, this means a Go struct with exported fields +of the appropriate types listed in the expected order can be used to +automatically encode / decode the XDR data thereby eliminating the need to write +a lot of boilerplate code to encode/decode and error check each piece of XDR +data as is typically required with C based XDR libraries. + +Go Type to XDR Type Mappings + +The following chart shows an overview of how Go types are mapped to XDR types +for automatic marshalling and unmarshalling. The documentation for the Marshal +and Unmarshal functions has specific details of how the mapping proceeds. + + Go Type <-> XDR Type + -------------------- + int8, int16, int32, int <-> XDR Integer + uint8, uint16, uint32, uint <-> XDR Unsigned Integer + int64 <-> XDR Hyper Integer + uint64 <-> XDR Unsigned Hyper Integer + bool <-> XDR Boolean + float32 <-> XDR Floating-Point + float64 <-> XDR Double-Precision Floating-Point + string <-> XDR String + byte <-> XDR Integer + []byte <-> XDR Variable-Length Opaque Data + [#]byte <-> XDR Fixed-Length Opaque Data + []<type> <-> XDR Variable-Length Array + [#]<type> <-> XDR Fixed-Length Array + struct <-> XDR Structure + map <-> XDR Variable-Length Array of two-element XDR Structures + time.Time <-> XDR String encoded with RFC3339 nanosecond precision + +Notes and Limitations: + + * Automatic marshalling and unmarshalling of variable and fixed-length + arrays of uint8s require a special struct tag `xdropaque:"false"` + since byte slices and byte arrays are assumed to be opaque data and + byte is a Go alias for uint8 thus indistinguishable under reflection + * Channel, complex, and function types cannot be encoded + * Interfaces without a concrete value cannot be encoded + * Cyclic data structures are not supported and will result in infinite + loops + * Strings are marshalled and unmarshalled with UTF-8 character encoding + which differs from the XDR specification of ASCII, however UTF-8 is + backwards compatible with ASCII so this should rarely cause issues + + +Encoding + +To encode XDR data, use the Marshal function. + func Marshal(w io.Writer, v interface{}) (int, error) + +For example, given the following code snippet: + + type ImageHeader struct { + Signature [3]byte + Version uint32 + IsGrayscale bool + NumSections uint32 + } + h := ImageHeader{[3]byte{0xAB, 0xCD, 0xEF}, 2, true, 10} + + var w bytes.Buffer + bytesWritten, err := xdr.Marshal(&w, &h) + // Error check elided + +The result, encodedData, will then contain the following XDR encoded byte +sequence: + + 0xAB, 0xCD, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x0A + + +In addition, while the automatic marshalling discussed above will work for the +vast majority of cases, an Encoder object is provided that can be used to +manually encode XDR primitives for complex scenarios where automatic +reflection-based encoding won't work. The included examples provide a sample of +manual usage via an Encoder. + + +Decoding + +To decode XDR data, use the Unmarshal function. + func Unmarshal(r io.Reader, v interface{}) (int, error) + +For example, given the following code snippet: + + type ImageHeader struct { + Signature [3]byte + Version uint32 + IsGrayscale bool + NumSections uint32 + } + + // Using output from the Encoding section above. + encodedData := []byte{ + 0xAB, 0xCD, 0xEF, 0x00, + 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x0A, + } + + var h ImageHeader + bytesRead, err := xdr.Unmarshal(bytes.NewReader(encodedData), &h) + // Error check elided + +The struct instance, h, will then contain the following values: + + h.Signature = [3]byte{0xAB, 0xCD, 0xEF} + h.Version = 2 + h.IsGrayscale = true + h.NumSections = 10 + +In addition, while the automatic unmarshalling discussed above will work for the +vast majority of cases, a Decoder object is provided that can be used to +manually decode XDR primitives for complex scenarios where automatic +reflection-based decoding won't work. The included examples provide a sample of +manual usage via a Decoder. + +Errors + +All errors are either of type UnmarshalError or MarshalError. Both provide +human-readable output as well as an ErrorCode field which can be inspected by +sophisticated callers if necessary. + +See the documentation of UnmarshalError, MarshalError, and ErrorCode for further +details. +*/ +package xdr diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go new file mode 100644 index 000000000..7bac2681d --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/encode.go @@ -0,0 +1,669 @@ +/* + * Copyright (c) 2012-2014 Dave Collins <dave@davec.name> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package xdr + +import ( + "fmt" + "io" + "math" + "reflect" + "time" +) + +var errIOEncode = "%s while encoding %d bytes" + +/* +Marshal writes the XDR encoding of v to writer w and returns the number of bytes +written. It traverses v recursively and automatically indirects pointers +through arbitrary depth to encode the actual value pointed to. + +Marshal uses reflection to determine the type of the concrete value contained by +v and performs a mapping of Go types to the underlying XDR types as follows: + + Go Type -> XDR Type + -------------------- + int8, int16, int32, int -> XDR Integer + uint8, uint16, uint32, uint -> XDR Unsigned Integer + int64 -> XDR Hyper Integer + uint64 -> XDR Unsigned Hyper Integer + bool -> XDR Boolean + float32 -> XDR Floating-Point + float64 -> XDR Double-Precision Floating-Point + string -> XDR String + byte -> XDR Integer + []byte -> XDR Variable-Length Opaque Data + [#]byte -> XDR Fixed-Length Opaque Data + []<type> -> XDR Variable-Length Array + [#]<type> -> XDR Fixed-Length Array + struct -> XDR Structure + map -> XDR Variable-Length Array of two-element XDR Structures + time.Time -> XDR String encoded with RFC3339 nanosecond precision + +Notes and Limitations: + + * Automatic marshalling of variable and fixed-length arrays of uint8s + requires a special struct tag `xdropaque:"false"` since byte slices and + byte arrays are assumed to be opaque data and byte is a Go alias for uint8 + thus indistinguishable under reflection + * Channel, complex, and function types cannot be encoded + * Interfaces without a concrete value cannot be encoded + * Cyclic data structures are not supported and will result in infinite loops + * Strings are marshalled with UTF-8 character encoding which differs from + the XDR specification of ASCII, however UTF-8 is backwards compatible with + ASCII so this should rarely cause issues + +If any issues are encountered during the marshalling process, a MarshalError is +returned with a human readable description as well as an ErrorCode value for +further inspection from sophisticated callers. Some potential issues are +unsupported Go types, attempting to encode more opaque data than can be +represented by a single opaque XDR entry, and exceeding max slice limitations. +*/ +func Marshal(w io.Writer, v interface{}) (int, error) { + enc := Encoder{w: w} + return enc.Encode(v) +} + +// An Encoder wraps an io.Writer that will receive the XDR encoded byte stream. +// See NewEncoder. +type Encoder struct { + w io.Writer +} + +// EncodeInt writes the XDR encoded representation of the passed 32-bit signed +// integer to the encapsulated writer and returns the number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.1 - Integer +// 32-bit big-endian signed integer in range [-2147483648, 2147483647] +func (enc *Encoder) EncodeInt(v int32) (int, error) { + var b [4]byte + b[0] = byte(v >> 24) + b[1] = byte(v >> 16) + b[2] = byte(v >> 8) + b[3] = byte(v) + + n, err := enc.w.Write(b[:]) + if err != nil { + msg := fmt.Sprintf(errIOEncode, err.Error(), 4) + err := marshalError("EncodeInt", ErrIO, msg, b[:n], err) + return n, err + } + + return n, nil +} + +// EncodeUint writes the XDR encoded representation of the passed 32-bit +// unsigned integer to the encapsulated writer and returns the number of bytes +// written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.2 - Unsigned Integer +// 32-bit big-endian unsigned integer in range [0, 4294967295] +func (enc *Encoder) EncodeUint(v uint32) (int, error) { + var b [4]byte + b[0] = byte(v >> 24) + b[1] = byte(v >> 16) + b[2] = byte(v >> 8) + b[3] = byte(v) + + n, err := enc.w.Write(b[:]) + if err != nil { + msg := fmt.Sprintf(errIOEncode, err.Error(), 4) + err := marshalError("EncodeUint", ErrIO, msg, b[:n], err) + return n, err + } + + return n, nil +} + +// EncodeEnum treats the passed 32-bit signed integer as an enumeration value +// and, if it is in the list of passed valid enumeration values, writes the XDR +// encoded representation of it to the encapsulated writer. It returns the +// number of bytes written. +// +// A MarshalError is returned if the enumeration value is not one of the +// provided valid values or if writing the data fails. +// +// Reference: +// RFC Section 4.3 - Enumeration +// Represented as an XDR encoded signed integer +func (enc *Encoder) EncodeEnum(v int32, validEnums map[int32]bool) (int, error) { + if !validEnums[v] { + err := marshalError("EncodeEnum", ErrBadEnumValue, + "invalid enum", v, nil) + return 0, err + } + return enc.EncodeInt(v) +} + +// EncodeBool writes the XDR encoded representation of the passed boolean to the +// encapsulated writer and returns the number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.4 - Boolean +// Represented as an XDR encoded enumeration where 0 is false and 1 is true +func (enc *Encoder) EncodeBool(v bool) (int, error) { + i := int32(0) + if v == true { + i = 1 + } + return enc.EncodeInt(i) +} + +// EncodeHyper writes the XDR encoded representation of the passed 64-bit +// signed integer to the encapsulated writer and returns the number of bytes +// written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.5 - Hyper Integer +// 64-bit big-endian signed integer in range [-9223372036854775808, 9223372036854775807] +func (enc *Encoder) EncodeHyper(v int64) (int, error) { + var b [8]byte + b[0] = byte(v >> 56) + b[1] = byte(v >> 48) + b[2] = byte(v >> 40) + b[3] = byte(v >> 32) + b[4] = byte(v >> 24) + b[5] = byte(v >> 16) + b[6] = byte(v >> 8) + b[7] = byte(v) + + n, err := enc.w.Write(b[:]) + if err != nil { + msg := fmt.Sprintf(errIOEncode, err.Error(), 8) + err := marshalError("EncodeHyper", ErrIO, msg, b[:n], err) + return n, err + } + + return n, nil +} + +// EncodeUhyper writes the XDR encoded representation of the passed 64-bit +// unsigned integer to the encapsulated writer and returns the number of bytes +// written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.5 - Unsigned Hyper Integer +// 64-bit big-endian unsigned integer in range [0, 18446744073709551615] +func (enc *Encoder) EncodeUhyper(v uint64) (int, error) { + var b [8]byte + b[0] = byte(v >> 56) + b[1] = byte(v >> 48) + b[2] = byte(v >> 40) + b[3] = byte(v >> 32) + b[4] = byte(v >> 24) + b[5] = byte(v >> 16) + b[6] = byte(v >> 8) + b[7] = byte(v) + + n, err := enc.w.Write(b[:]) + if err != nil { + msg := fmt.Sprintf(errIOEncode, err.Error(), 8) + err := marshalError("EncodeUhyper", ErrIO, msg, b[:n], err) + return n, err + } + + return n, nil +} + +// EncodeFloat writes the XDR encoded representation of the passed 32-bit +// (single-precision) floating point to the encapsulated writer and returns the +// number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.6 - Floating Point +// 32-bit single-precision IEEE 754 floating point +func (enc *Encoder) EncodeFloat(v float32) (int, error) { + ui := math.Float32bits(v) + return enc.EncodeUint(ui) +} + +// EncodeDouble writes the XDR encoded representation of the passed 64-bit +// (double-precision) floating point to the encapsulated writer and returns the +// number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.7 - Double-Precision Floating Point +// 64-bit double-precision IEEE 754 floating point +func (enc *Encoder) EncodeDouble(v float64) (int, error) { + ui := math.Float64bits(v) + return enc.EncodeUhyper(ui) +} + +// RFC Section 4.8 - Quadruple-Precision Floating Point +// 128-bit quadruple-precision floating point +// Not Implemented + +// EncodeFixedOpaque treats the passed byte slice as opaque data of a fixed +// size and writes the XDR encoded representation of it to the encapsulated +// writer. It returns the number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.9 - Fixed-Length Opaque Data +// Fixed-length uninterpreted data zero-padded to a multiple of four +func (enc *Encoder) EncodeFixedOpaque(v []byte) (int, error) { + l := len(v) + pad := (4 - (l % 4)) % 4 + + // Write the actual bytes. + n, err := enc.w.Write(v) + if err != nil { + msg := fmt.Sprintf(errIOEncode, err.Error(), len(v)) + err := marshalError("EncodeFixedOpaque", ErrIO, msg, v[:n], err) + return n, err + } + + // Write any padding if needed. + if pad > 0 { + b := make([]byte, pad) + n2, err := enc.w.Write(b) + n += n2 + if err != nil { + written := make([]byte, l+n2) + copy(written, v) + copy(written[l:], b[:n2]) + msg := fmt.Sprintf(errIOEncode, err.Error(), l+pad) + err := marshalError("EncodeFixedOpaque", ErrIO, msg, + written, err) + return n, err + } + } + + return n, nil +} + +// EncodeOpaque treats the passed byte slice as opaque data of a variable +// size and writes the XDR encoded representation of it to the encapsulated +// writer. It returns the number of bytes written. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.10 - Variable-Length Opaque Data +// Unsigned integer length followed by fixed opaque data of that length +func (enc *Encoder) EncodeOpaque(v []byte) (int, error) { + // Length of opaque data. + n, err := enc.EncodeUint(uint32(len(v))) + if err != nil { + return n, err + } + + n2, err := enc.EncodeFixedOpaque(v) + n += n2 + return n, err +} + +// EncodeString writes the XDR encoded representation of the passed string +// to the encapsulated writer and returns the number of bytes written. +// Character encoding is assumed to be UTF-8 and therefore ASCII compatible. If +// the underlying character encoding is not compatible with this assumption, the +// data can instead be written as variable-length opaque data (EncodeOpaque) and +// manually converted as needed. +// +// A MarshalError with an error code of ErrIO is returned if writing the data +// fails. +// +// Reference: +// RFC Section 4.11 - String +// Unsigned integer length followed by bytes zero-padded to a multiple of four +func (enc *Encoder) EncodeString(v string) (int, error) { + // Length of string. + n, err := enc.EncodeUint(uint32(len(v))) + if err != nil { + return n, err + } + + n2, err := enc.EncodeFixedOpaque([]byte(v)) + n += n2 + return n, err +} + +// encodeFixedArray writes the XDR encoded representation of each element +// in the passed array represented by the reflection value to the encapsulated +// writer and returns the number of bytes written. The ignoreOpaque flag +// controls whether or not uint8 (byte) elements should be encoded individually +// or as a fixed sequence of opaque data. +// +// A MarshalError is returned if any issues are encountered while encoding +// the array elements. +// +// Reference: +// RFC Section 4.12 - Fixed-Length Array +// Individually XDR encoded array elements +func (enc *Encoder) encodeFixedArray(v reflect.Value, ignoreOpaque bool) (int, error) { + // Treat [#]byte (byte is alias for uint8) as opaque data unless ignored. + if !ignoreOpaque && v.Type().Elem().Kind() == reflect.Uint8 { + // Create a slice of the underlying array for better efficiency + // when possible. Can't create a slice of an unaddressable + // value. + if v.CanAddr() { + return enc.EncodeFixedOpaque(v.Slice(0, v.Len()).Bytes()) + } + + // When the underlying array isn't addressable fall back to + // copying the array into a new slice. This is rather ugly, but + // the inability to create a constant slice from an + // unaddressable array is a limitation of Go. + slice := make([]byte, v.Len(), v.Len()) + reflect.Copy(reflect.ValueOf(slice), v) + return enc.EncodeFixedOpaque(slice) + } + + // Encode each array element. + var n int + for i := 0; i < v.Len(); i++ { + n2, err := enc.encode(v.Index(i)) + n += n2 + if err != nil { + return n, err + } + } + + return n, nil +} + +// encodeArray writes an XDR encoded integer representing the number of +// elements in the passed slice represented by the reflection value followed by +// the XDR encoded representation of each element in slice to the encapsulated +// writer and returns the number of bytes written. The ignoreOpaque flag +// controls whether or not uint8 (byte) elements should be encoded individually +// or as a variable sequence of opaque data. +// +// A MarshalError is returned if any issues are encountered while encoding +// the array elements. +// +// Reference: +// RFC Section 4.13 - Variable-Length Array +// Unsigned integer length followed by individually XDR encoded array elements +func (enc *Encoder) encodeArray(v reflect.Value, ignoreOpaque bool) (int, error) { + numItems := uint32(v.Len()) + n, err := enc.EncodeUint(numItems) + if err != nil { + return n, err + } + + n2, err := enc.encodeFixedArray(v, ignoreOpaque) + n += n2 + return n, err +} + +// encodeStruct writes an XDR encoded representation of each value in the +// exported fields of the struct represented by the passed reflection value to +// the encapsulated writer and returns the number of bytes written. Pointers +// are automatically indirected through arbitrary depth to encode the actual +// value pointed to. +// +// A MarshalError is returned if any issues are encountered while encoding +// the elements. +// +// Reference: +// RFC Section 4.14 - Structure +// XDR encoded elements in the order of their declaration in the struct +func (enc *Encoder) encodeStruct(v reflect.Value) (int, error) { + var n int + vt := v.Type() + for i := 0; i < v.NumField(); i++ { + // Skip unexported fields and indirect through pointers. + vtf := vt.Field(i) + if vtf.PkgPath != "" { + continue + } + vf := v.Field(i) + vf = enc.indirect(vf) + + // Handle non-opaque data to []uint8 and [#]uint8 based on struct tag. + tag := vtf.Tag.Get("xdropaque") + if tag == "false" { + switch vf.Kind() { + case reflect.Slice: + n2, err := enc.encodeArray(vf, true) + n += n2 + if err != nil { + return n, err + } + continue + + case reflect.Array: + n2, err := enc.encodeFixedArray(vf, true) + n += n2 + if err != nil { + return n, err + } + continue + } + } + + // Encode each struct field. + n2, err := enc.encode(vf) + n += n2 + if err != nil { + return n, err + } + } + + return n, nil +} + +// RFC Section 4.15 - Discriminated Union +// RFC Section 4.16 - Void +// RFC Section 4.17 - Constant +// RFC Section 4.18 - Typedef +// RFC Section 4.19 - Optional data +// RFC Sections 4.15 though 4.19 only apply to the data specification language +// which is not implemented by this package. In the case of discriminated +// unions, struct tags are used to perform a similar function. + +// encodeMap treats the map represented by the passed reflection value as a +// variable-length array of 2-element structures whose fields are of the same +// type as the map keys and elements and writes its XDR encoded representation +// to the encapsulated writer. It returns the number of bytes written. +// +// A MarshalError is returned if any issues are encountered while encoding +// the elements. +func (enc *Encoder) encodeMap(v reflect.Value) (int, error) { + // Number of elements. + n, err := enc.EncodeUint(uint32(v.Len())) + if err != nil { + return n, err + } + + // Encode each key and value according to their type. + for _, key := range v.MapKeys() { + n2, err := enc.encode(key) + n += n2 + if err != nil { + return n, err + } + + n2, err = enc.encode(v.MapIndex(key)) + n += n2 + if err != nil { + return n, err + } + } + + return n, nil +} + +// encodeInterface examines the interface represented by the passed reflection +// value to detect whether it is an interface that can be encoded if it is, +// extracts the underlying value to pass back into the encode function for +// encoding according to its type. +// +// A MarshalError is returned if any issues are encountered while encoding +// the interface. +func (enc *Encoder) encodeInterface(v reflect.Value) (int, error) { + if v.IsNil() || !v.CanInterface() { + msg := fmt.Sprintf("can't encode nil interface") + err := marshalError("encodeInterface", ErrNilInterface, msg, + nil, nil) + return 0, err + } + + // Extract underlying value from the interface and indirect through pointers. + ve := reflect.ValueOf(v.Interface()) + ve = enc.indirect(ve) + return enc.encode(ve) +} + +// encode is the main workhorse for marshalling via reflection. It uses +// the passed reflection value to choose the XDR primitives to encode into +// the encapsulated writer and returns the number of bytes written. It is a +// recursive function, so cyclic data structures are not supported and will +// result in an infinite loop. +func (enc *Encoder) encode(v reflect.Value) (int, error) { + if !v.IsValid() { + msg := fmt.Sprintf("type '%s' is not valid", v.Kind().String()) + err := marshalError("encode", ErrUnsupportedType, msg, nil, nil) + return 0, err + } + + // Indirect through pointers to get at the concrete value. + ve := enc.indirect(v) + + // Handle time.Time values by encoding them as an RFC3339 formatted + // string with nanosecond precision. Check the type string before + // doing a full blown conversion to interface and type assertion since + // checking a string is much quicker. + if ve.Type().String() == "time.Time" && ve.CanInterface() { + viface := ve.Interface() + if tv, ok := viface.(time.Time); ok { + return enc.EncodeString(tv.Format(time.RFC3339Nano)) + } + } + + // Handle native Go types. + switch ve.Kind() { + case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int: + return enc.EncodeInt(int32(ve.Int())) + + case reflect.Int64: + return enc.EncodeHyper(ve.Int()) + + case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint: + return enc.EncodeUint(uint32(ve.Uint())) + + case reflect.Uint64: + return enc.EncodeUhyper(ve.Uint()) + + case reflect.Bool: + return enc.EncodeBool(ve.Bool()) + + case reflect.Float32: + return enc.EncodeFloat(float32(ve.Float())) + + case reflect.Float64: + return enc.EncodeDouble(ve.Float()) + + case reflect.String: + return enc.EncodeString(ve.String()) + + case reflect.Array: + return enc.encodeFixedArray(ve, false) + + case reflect.Slice: + return enc.encodeArray(ve, false) + + case reflect.Struct: + return enc.encodeStruct(ve) + + case reflect.Map: + return enc.encodeMap(ve) + + case reflect.Interface: + return enc.encodeInterface(ve) + } + + // The only unhandled types left are unsupported. At the time of this + // writing the only remaining unsupported types that exist are + // reflect.Uintptr and reflect.UnsafePointer. + msg := fmt.Sprintf("unsupported Go type '%s'", ve.Kind().String()) + err := marshalError("encode", ErrUnsupportedType, msg, nil, nil) + return 0, err +} + +// indirect dereferences pointers until it reaches a non-pointer. This allows +// transparent encoding through arbitrary levels of indirection. +func (enc *Encoder) indirect(v reflect.Value) reflect.Value { + rv := v + for rv.Kind() == reflect.Ptr { + rv = rv.Elem() + } + return rv +} + +// Encode operates identically to the Marshal function with the exception of +// using the writer associated with the Encoder for the destination of the +// XDR-encoded data instead of a user-supplied writer. See the Marshal +// documentation for specifics. +func (enc *Encoder) Encode(v interface{}) (int, error) { + if v == nil { + msg := "can't marshal nil interface" + err := marshalError("Marshal", ErrNilInterface, msg, nil, nil) + return 0, err + } + + vv := reflect.ValueOf(v) + vve := vv + for vve.Kind() == reflect.Ptr { + if vve.IsNil() { + msg := fmt.Sprintf("can't marshal nil pointer '%v'", + vv.Type().String()) + err := marshalError("Marshal", ErrBadArguments, msg, + nil, nil) + return 0, err + } + vve = vve.Elem() + } + + return enc.encode(vve) +} + +// NewEncoder returns an object that can be used to manually choose fields to +// XDR encode to the passed writer w. Typically, Marshal should be used instead +// of manually creating an Encoder. An Encoder, along with several of its +// methods to encode XDR primitives, is exposed so it is possible to perform +// manual encoding of data without relying on reflection should it be necessary +// in complex scenarios where automatic reflection-based encoding won't work. +func NewEncoder(w io.Writer) *Encoder { + return &Encoder{w: w} +} diff --git a/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go new file mode 100644 index 000000000..42079ad35 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2/error.go @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2012-2014 Dave Collins <dave@davec.name> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +package xdr + +import "fmt" + +// ErrorCode identifies a kind of error. +type ErrorCode int + +const ( + // ErrBadArguments indicates arguments passed to the function are not + // what was expected. + ErrBadArguments ErrorCode = iota + + // ErrUnsupportedType indicates the Go type is not a supported type for + // marshalling and unmarshalling XDR data. + ErrUnsupportedType + + // ErrBadEnumValue indicates an enumeration value is not in the list of + // valid values. + ErrBadEnumValue + + // ErrNotSettable indicates an interface value cannot be written to. + // This usually means the interface value was not passed with the & + // operator, but it can also happen if automatic pointer allocation + // fails. + ErrNotSettable + + // ErrOverflow indicates that the data in question is too large to fit + // into the corresponding Go or XDR data type. For example, an integer + // decoded from XDR that is too large to fit into a target type of int8, + // or opaque data that exceeds the max length of a Go slice. + ErrOverflow + + // ErrNilInterface indicates an interface with no concrete type + // information was encountered. Type information is necessary to + // perform mapping between XDR and Go types. + ErrNilInterface + + // ErrIO indicates an error was encountered while reading or writing to + // an io.Reader or io.Writer, respectively. The actual underlying error + // will be available via the Err field of the MarshalError or + // UnmarshalError struct. + ErrIO + + // ErrParseTime indicates an error was encountered while parsing an + // RFC3339 formatted time value. The actual underlying error will be + // available via the Err field of the UnmarshalError struct. + ErrParseTime +) + +// Map of ErrorCode values back to their constant names for pretty printing. +var errorCodeStrings = map[ErrorCode]string{ + ErrBadArguments: "ErrBadArguments", + ErrUnsupportedType: "ErrUnsupportedType", + ErrBadEnumValue: "ErrBadEnumValue", + ErrNotSettable: "ErrNotSettable", + ErrOverflow: "ErrOverflow", + ErrNilInterface: "ErrNilInterface", + ErrIO: "ErrIO", + ErrParseTime: "ErrParseTime", +} + +// String returns the ErrorCode as a human-readable name. +func (e ErrorCode) String() string { + if s := errorCodeStrings[e]; s != "" { + return s + } + return fmt.Sprintf("Unknown ErrorCode (%d)", e) +} + +// UnmarshalError describes a problem encountered while unmarshaling data. +// Some potential issues are unsupported Go types, attempting to decode a value +// which is too large to fit into a specified Go type, and exceeding max slice +// limitations. +type UnmarshalError struct { + ErrorCode ErrorCode // Describes the kind of error + Func string // Function name + Value interface{} // Value actually parsed where appropriate + Description string // Human readable description of the issue + Err error // The underlying error for IO errors +} + +// Error satisfies the error interface and prints human-readable errors. +func (e *UnmarshalError) Error() string { + switch e.ErrorCode { + case ErrBadEnumValue, ErrOverflow, ErrIO, ErrParseTime: + return fmt.Sprintf("xdr:%s: %s - read: '%v'", e.Func, + e.Description, e.Value) + } + return fmt.Sprintf("xdr:%s: %s", e.Func, e.Description) +} + +// unmarshalError creates an error given a set of arguments and will copy byte +// slices into the Value field since they might otherwise be changed from from +// the original value. +func unmarshalError(f string, c ErrorCode, desc string, v interface{}, err error) *UnmarshalError { + e := &UnmarshalError{ErrorCode: c, Func: f, Description: desc, Err: err} + switch t := v.(type) { + case []byte: + slice := make([]byte, len(t)) + copy(slice, t) + e.Value = slice + default: + e.Value = v + } + + return e +} + +// IsIO returns a boolean indicating whether the error is known to report that +// the underlying reader or writer encountered an ErrIO. +func IsIO(err error) bool { + switch e := err.(type) { + case *UnmarshalError: + return e.ErrorCode == ErrIO + case *MarshalError: + return e.ErrorCode == ErrIO + } + return false +} + +// MarshalError describes a problem encountered while marshaling data. +// Some potential issues are unsupported Go types, attempting to encode more +// opaque data than can be represented by a single opaque XDR entry, and +// exceeding max slice limitations. +type MarshalError struct { + ErrorCode ErrorCode // Describes the kind of error + Func string // Function name + Value interface{} // Value actually parsed where appropriate + Description string // Human readable description of the issue + Err error // The underlying error for IO errors +} + +// Error satisfies the error interface and prints human-readable errors. +func (e *MarshalError) Error() string { + switch e.ErrorCode { + case ErrIO: + return fmt.Sprintf("xdr:%s: %s - wrote: '%v'", e.Func, + e.Description, e.Value) + case ErrBadEnumValue: + return fmt.Sprintf("xdr:%s: %s - value: '%v'", e.Func, + e.Description, e.Value) + } + return fmt.Sprintf("xdr:%s: %s", e.Func, e.Description) +} + +// marshalError creates an error given a set of arguments and will copy byte +// slices into the Value field since they might otherwise be changed from from +// the original value. +func marshalError(f string, c ErrorCode, desc string, v interface{}, err error) *MarshalError { + e := &MarshalError{ErrorCode: c, Func: f, Description: desc, Err: err} + switch t := v.(type) { + case []byte: + slice := make([]byte, len(t)) + copy(slice, t) + e.Value = slice + default: + e.Value = v + } + + return e +} diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirt.go b/vendor/github.com/digitalocean/go-libvirt/libvirt.go new file mode 100644 index 000000000..a76eafdd2 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/libvirt.go @@ -0,0 +1,608 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package libvirt is a pure Go implementation of the libvirt RPC protocol. +// For more information on the protocol, see https://libvirt.org/internals/l.html +package libvirt + +// We'll use c-for-go to extract the consts and typedefs from the libvirt +// sources so we don't have to duplicate them here. +//go:generate scripts/gen-consts.sh + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "net" + "sync" + + "github.com/digitalocean/go-libvirt/internal/constants" + "github.com/digitalocean/go-libvirt/internal/event" + xdr "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2" +) + +// ErrEventsNotSupported is returned by Events() if event streams +// are unsupported by either QEMU or libvirt. +var ErrEventsNotSupported = errors.New("event monitor is not supported") + +// Libvirt implements libvirt's remote procedure call protocol. +type Libvirt struct { + conn net.Conn + r *bufio.Reader + w *bufio.Writer + mu *sync.Mutex + + // method callbacks + cmux sync.RWMutex + callbacks map[int32]chan response + + // event listeners + emux sync.RWMutex + events map[int32]*event.Stream + + // next request serial number + s int32 +} + +// DomainEvent represents a libvirt domain event. +type DomainEvent struct { + CallbackID int32 + Domain Domain + Event string + Seconds uint64 + Microseconds uint32 + Padding uint8 + Details []byte +} + +// GetCallbackID returns the callback ID of a QEMU domain event. +func (de DomainEvent) GetCallbackID() int32 { + return de.CallbackID +} + +// GetCallbackID returns the callback ID of a libvirt lifecycle event. +func (m DomainEventCallbackLifecycleMsg) GetCallbackID() int32 { + return m.CallbackID +} + +// qemuError represents a QEMU process error. +type qemuError struct { + Error struct { + Class string `json:"class"` + Description string `json:"desc"` + } `json:"error"` +} + +// Capabilities returns an XML document describing the host's capabilties. +func (l *Libvirt) Capabilities() ([]byte, error) { + caps, err := l.ConnectGetCapabilities() + return []byte(caps), err +} + +// Connect establishes communication with the libvirt server. +// The underlying libvirt socket connection must be previously established. +func (l *Libvirt) Connect() error { + payload := struct { + Padding [3]byte + Name string + Flags uint32 + }{ + Padding: [3]byte{0x1, 0x0, 0x0}, + Name: "qemu:///system", + Flags: 0, + } + + buf, err := encode(&payload) + if err != nil { + return err + } + + // libvirt requires that we call auth-list prior to connecting, + // event when no authentication is used. + _, err = l.request(constants.ProcAuthList, constants.Program, buf) + if err != nil { + return err + } + + _, err = l.request(constants.ProcConnectOpen, constants.Program, buf) + if err != nil { + return err + } + + return nil +} + +// Disconnect shuts down communication with the libvirt server and closes the +// underlying net.Conn. +func (l *Libvirt) Disconnect() error { + // close event streams + for _, ev := range l.events { + l.unsubscribeEvents(ev) + } + + // Deregister all callbacks to prevent blocking on clients with + // outstanding requests + l.deregisterAll() + + _, err := l.request(constants.ProcConnectClose, constants.Program, nil) + if err != nil { + return err + } + + return l.conn.Close() +} + +// Domains returns a list of all domains managed by libvirt. +// +// Deprecated: use ConnectListAllDomains instead. +func (l *Libvirt) Domains() ([]Domain, error) { + // these are the flags as passed by `virsh list --all` + flags := ConnectListDomainsActive | ConnectListDomainsInactive + domains, _, err := l.ConnectListAllDomains(1, flags) + return domains, err +} + +// DomainState returns state of the domain managed by libvirt. +// +// Deprecated: use DomainGetState instead. +func (l *Libvirt) DomainState(dom string) (DomainState, error) { + d, err := l.lookup(dom) + if err != nil { + return DomainNostate, err + } + + state, _, err := l.DomainGetState(d, 0) + return DomainState(state), err +} + +// SubscribeQEMUEvents streams domain events until the provided context is +// cancelled. If a problem is encountered setting up the event monitor +// connection an error will be returned. Errors encountered during streaming +// will cause the returned event channel to be closed. QEMU domain events. +func (l *Libvirt) SubscribeQEMUEvents(ctx context.Context, dom string) (<-chan DomainEvent, error) { + d, err := l.lookup(dom) + if err != nil { + return nil, err + } + + callbackID, err := l.QEMUConnectDomainMonitorEventRegister([]Domain{d}, nil, 0) + if err != nil { + return nil, err + } + + stream := event.NewStream(constants.QEMUProgram, callbackID) + l.addStream(stream) + ch := make(chan DomainEvent) + go func() { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + defer l.unsubscribeQEMUEvents(stream) + defer stream.Shutdown() + defer func() { close(ch) }() + + for { + select { + case ev, ok := <-stream.Recv(): + if !ok { + return + } + ch <- *ev.(*DomainEvent) + case <-ctx.Done(): + return + } + } + }() + + return ch, nil +} + +// unsubscribeQEMUEvents stops the flow of events from QEMU through libvirt. +func (l *Libvirt) unsubscribeQEMUEvents(stream *event.Stream) error { + err := l.QEMUConnectDomainMonitorEventDeregister(stream.CallbackID) + l.removeStream(stream.CallbackID) + + return err +} + +// SubscribeEvents allows the caller to subscribe to any of the event types +// supported by libvirt. The events will continue to be streamed until the +// caller cancels the provided context. After canceling the context, callers +// should wait until the channel is closed to be sure they're collected all the +// events. +func (l *Libvirt) SubscribeEvents(ctx context.Context, eventID DomainEventID, + dom OptDomain) (<-chan interface{}, error) { + + callbackID, err := l.ConnectDomainEventCallbackRegisterAny(int32(eventID), nil) + if err != nil { + return nil, err + } + + stream := event.NewStream(constants.QEMUProgram, callbackID) + l.addStream(stream) + + ch := make(chan interface{}) + go func() { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + defer l.unsubscribeEvents(stream) + defer stream.Shutdown() + defer func() { close(ch) }() + + for { + select { + case ev, ok := <-stream.Recv(): + if !ok { + return + } + ch <- ev + case <-ctx.Done(): + return + } + } + }() + + return ch, nil +} + +// unsubscribeEvents stops the flow of the specified events from libvirt. There +// are two steps to this process: a call to libvirt to deregister our callback, +// and then removing the callback from the list used by the `route` fucntion. If +// the deregister call fails, we'll return the error, but still remove the +// callback from the list. That's ok; if any events arrive after this point, the +// route function will drop them when it finds no registered handler. +func (l *Libvirt) unsubscribeEvents(stream *event.Stream) error { + err := l.ConnectDomainEventCallbackDeregisterAny(stream.CallbackID) + l.removeStream(stream.CallbackID) + + return err +} + +// LifecycleEvents streams lifecycle events until the provided context is +// cancelled. If a problem is encountered setting up the event monitor +// connection, an error will be returned. Errors encountered during streaming +// will cause the returned event channel to be closed. +func (l *Libvirt) LifecycleEvents(ctx context.Context) (<-chan DomainEventLifecycleMsg, error) { + callbackID, err := l.ConnectDomainEventCallbackRegisterAny(int32(DomainEventIDLifecycle), nil) + if err != nil { + return nil, err + } + + stream := event.NewStream(constants.Program, callbackID) + l.addStream(stream) + + ch := make(chan DomainEventLifecycleMsg) + + go func() { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + defer l.unsubscribeEvents(stream) + defer stream.Shutdown() + defer func() { close(ch) }() + + for { + select { + case ev, ok := <-stream.Recv(): + if !ok { + return + } + ch <- ev.(*DomainEventCallbackLifecycleMsg).Msg + case <-ctx.Done(): + return + } + } + }() + + return ch, nil +} + +// Run executes the given QAPI command against a domain's QEMU instance. +// For a list of available QAPI commands, see: +// http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD +func (l *Libvirt) Run(dom string, cmd []byte) ([]byte, error) { + d, err := l.lookup(dom) + if err != nil { + return nil, err + } + + payload := struct { + Domain Domain + Command []byte + Flags uint32 + }{ + Domain: d, + Command: cmd, + Flags: 0, + } + + buf, err := encode(&payload) + if err != nil { + return nil, err + } + + res, err := l.request(constants.QEMUProcDomainMonitorCommand, constants.QEMUProgram, buf) + if err != nil { + return nil, err + } + + // check for QEMU process errors + if err = getQEMUError(res); err != nil { + return nil, err + } + + r := bytes.NewReader(res.Payload) + dec := xdr.NewDecoder(r) + data, _, err := dec.DecodeFixedOpaque(int32(r.Len())) + if err != nil { + return nil, err + } + + // drop QMP control characters from start of line, and drop + // any trailing NULL characters from the end + return bytes.TrimRight(data[4:], "\x00"), nil +} + +// Secrets returns all secrets managed by the libvirt daemon. +// +// Deprecated: use ConnectListAllSecrets instead. +func (l *Libvirt) Secrets() ([]Secret, error) { + secrets, _, err := l.ConnectListAllSecrets(1, 0) + return secrets, err +} + +// StoragePool returns the storage pool associated with the provided name. +// An error is returned if the requested storage pool is not found. +// +// Deprecated: use StoragePoolLookupByName instead. +func (l *Libvirt) StoragePool(name string) (StoragePool, error) { + return l.StoragePoolLookupByName(name) +} + +// StoragePools returns a list of defined storage pools. Pools are filtered by +// the provided flags. See StoragePools*. +// +// Deprecated: use ConnectListAllStoragePools instead. +func (l *Libvirt) StoragePools(flags ConnectListAllStoragePoolsFlags) ([]StoragePool, error) { + pools, _, err := l.ConnectListAllStoragePools(1, flags) + return pools, err +} + +// Undefine undefines the domain specified by dom, e.g., 'prod-lb-01'. +// The flags argument allows additional options to be specified such as +// cleaning up snapshot metadata. For more information on available +// flags, see DomainUndefine*. +// +// Deprecated: use DomainUndefineFlags instead. +func (l *Libvirt) Undefine(dom string, flags DomainUndefineFlagsValues) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + return l.DomainUndefineFlags(d, flags) +} + +// Destroy destroys the domain specified by dom, e.g., 'prod-lb-01'. +// The flags argument allows additional options to be specified such as +// allowing a graceful shutdown with SIGTERM than SIGKILL. +// For more information on available flags, see DomainDestroy*. +// +// Deprecated: use DomainDestroyFlags instead. +func (l *Libvirt) Destroy(dom string, flags DomainDestroyFlagsValues) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + return l.DomainDestroyFlags(d, flags) +} + +// XML returns a domain's raw XML definition, akin to `virsh dumpxml <domain>`. +// See DomainXMLFlag* for optional flags. +// +// Deprecated: use DomainGetXMLDesc instead. +func (l *Libvirt) XML(dom string, flags DomainXMLFlags) ([]byte, error) { + d, err := l.lookup(dom) + if err != nil { + return nil, err + } + + xml, err := l.DomainGetXMLDesc(d, flags) + return []byte(xml), err +} + +// DefineXML defines a domain, but does not start it. +// +// Deprecated: use DomainDefineXMLFlags instead. +func (l *Libvirt) DefineXML(x []byte, flags DomainDefineFlags) error { + _, err := l.DomainDefineXMLFlags(string(x), flags) + return err +} + +// Version returns the version of the libvirt daemon. +// +// Deprecated: use ConnectGetLibVersion instead. +func (l *Libvirt) Version() (string, error) { + ver, err := l.ConnectGetLibVersion() + if err != nil { + return "", err + } + + // The version is provided as an int following this formula: + // version * 1,000,000 + minor * 1000 + micro + // See src/libvirt-host.c # virConnectGetLibVersion + major := ver / 1000000 + ver %= 1000000 + minor := ver / 1000 + ver %= 1000 + micro := ver + + versionString := fmt.Sprintf("%d.%d.%d", major, minor, micro) + return versionString, nil +} + +// Shutdown shuts down a domain. Note that the guest OS may ignore the request. +// If flags is set to 0 then the hypervisor will choose the method of shutdown it considers best. +// +// Deprecated: use DomainShutdownFlags instead. +func (l *Libvirt) Shutdown(dom string, flags DomainShutdownFlagValues) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + return l.DomainShutdownFlags(d, flags) +} + +// Reboot reboots the domain. Note that the guest OS may ignore the request. +// If flags is set to zero, then the hypervisor will choose the method of shutdown it considers best. +// +// Deprecated: use DomainReboot instead. +func (l *Libvirt) Reboot(dom string, flags DomainRebootFlagValues) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + return l.DomainReboot(d, flags) +} + +// Reset resets domain immediately without any guest OS shutdown +// +// Deprecated: use DomainReset instead. +func (l *Libvirt) Reset(dom string) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + return l.DomainReset(d, 0) +} + +// BlockLimit contains a name and value pair for a Get/SetBlockIOTune limit. The +// Name field is the name of the limit (to see a list of the limits that can be +// applied, execute the 'blkdeviotune' command on a VM in virsh). Callers can +// use the QEMUBlockIO... constants below for the Name value. The Value field is +// the limit to apply. +type BlockLimit struct { + Name string + Value uint64 +} + +// SetBlockIOTune changes the per-device block I/O tunables within a guest. +// Parameters are the name of the VM, the name of the disk device to which the +// limits should be applied, and 1 or more BlockLimit structs containing the +// actual limits. +// +// The limits which can be applied here are enumerated in the QEMUBlockIO... +// constants above, and you can also see the full list by executing the +// 'blkdeviotune' command on a VM in virsh. +// +// Example usage: +// SetBlockIOTune("vm-name", "vda", BlockLimit{libvirt.QEMUBlockIOWriteBytesSec, 1000000}) +// +// Deprecated: use DomainSetBlockIOTune instead. +func (l *Libvirt) SetBlockIOTune(dom string, disk string, limits ...BlockLimit) error { + d, err := l.lookup(dom) + if err != nil { + return err + } + + params := make([]TypedParam, len(limits)) + for ix, limit := range limits { + tpval := NewTypedParamValueUllong(limit.Value) + params[ix] = TypedParam{Field: limit.Name, Value: *tpval} + } + + return l.DomainSetBlockIOTune(d, disk, params, uint32(DomainAffectLive)) +} + +// GetBlockIOTune returns a slice containing the current block I/O tunables for +// a disk. +// +// Deprecated: use DomainGetBlockIOTune instead. +func (l *Libvirt) GetBlockIOTune(dom string, disk string) ([]BlockLimit, error) { + d, err := l.lookup(dom) + if err != nil { + return nil, err + } + + lims, _, err := l.DomainGetBlockIOTune(d, []string{disk}, 32, uint32(TypedParamStringOkay)) + if err != nil { + return nil, err + } + + var limits []BlockLimit + + // now decode each of the returned TypedParams. To do this we read the field + // name and type, then use the type information to decode the value. + for _, lim := range lims { + var l BlockLimit + name := lim.Field + switch lim.Value.I.(type) { + case uint64: + l = BlockLimit{Name: name, Value: lim.Value.I.(uint64)} + } + limits = append(limits, l) + } + + return limits, nil +} + +// lookup returns a domain as seen by libvirt. +func (l *Libvirt) lookup(name string) (Domain, error) { + return l.DomainLookupByName(name) +} + +// getQEMUError checks the provided response for QEMU process errors. +// If an error is found, it is extracted an returned, otherwise nil. +func getQEMUError(r response) error { + pl := bytes.NewReader(r.Payload) + dec := xdr.NewDecoder(pl) + + s, _, err := dec.DecodeString() + if err != nil { + return err + } + + var e qemuError + if err = json.Unmarshal([]byte(s), &e); err != nil { + return err + } + + if e.Error.Description != "" { + return errors.New(e.Error.Description) + } + + return nil +} + +// New configures a new Libvirt RPC connection. +func New(conn net.Conn) *Libvirt { + l := &Libvirt{ + conn: conn, + s: 0, + r: bufio.NewReader(conn), + w: bufio.NewWriter(conn), + mu: &sync.Mutex{}, + callbacks: make(map[int32]chan response), + events: make(map[int32]*event.Stream), + } + + go l.listen() + + return l +} diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirt.yml b/vendor/github.com/digitalocean/go-libvirt/libvirt.yml new file mode 100644 index 000000000..4d6cc2d50 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/libvirt.yml @@ -0,0 +1,64 @@ +# Configuration file for c-for-go, which go-libvirt uses to translate the const +# and type definitions from the C-language sources in the libvirt project into +# Go. This file is used by the c-for-go binary (github.com/xlab/c-for-go), which +# is called when 'go generate' is run. See libvirt.go for the command line used. +--- +GENERATOR: + PackageName: libvirt + PackageLicense: | + Copyright 2018 The go-libvirt Authors. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + Includes: [] + +PARSER: + # We can't use environment variables here, but we don't want to process the + # libvirt version installed in the system folders (if any). Instead we'll + # rely on our caller to link the libvirt source directory to lv_source/, and + # run on that code. This isn't ideal, but changes to c-for-go are needed to + # fix it. + IncludePaths: [./lv_source/include] + SourcesPaths: + - libvirt/libvirt.h + - libvirt/virterror.h + +TRANSLATOR: + ConstRules: + defines: eval + Rules: + global: + - {action: accept, from: "^vir"} + post-global: + - {action: replace, from: "^vir"} + - {load: snakecase} + # Follow golint's capitalization conventions. + - {action: replace, from: "Api([A-Z]|$)", to: "API$1"} + - {action: replace, from: "Cpu([A-Z]|$)", to: "CPU$1"} + - {action: replace, from: "Dns([A-Z]|$)", to: "DNS$1"} + - {action: replace, from: "Eof([A-Z]|$)", to: "EOF$1"} + - {action: replace, from: "Id([A-Z]|$)", to: "ID$1"} + - {action: replace, from: "Ip([A-Z]|$)", to: "IP$1"} + - {action: replace, from: "Tls([A-Z]|$)", to: "TLS$1"} + - {action: replace, from: "Uuid([A-Z]|$)", to: "UUID$1"} + - {action: replace, from: "Uri([A-Z]|$)", to: "URI$1"} + - {action: replace, from: "Vcpu([A-Z]|$)", to: "VCPU$1"} + - {action: replace, from: "Xml([A-Z]|$)", to: "XML$1"} + - {action: replace, from: "Rpc([A-Z]|$)", to: "RPC$1"} + - {action: replace, from: "Ssh([A-Z]|$)", to: "SSH$1"} + - {action: replace, from: "Http([A-Z]|$)", to: "HTTP$1"} + - {transform: unexport, from: "^(Err|From|War)"} + const: + - {action: accept, from: "^VIR_"} + # Special case to prevent a collision with a type: + - {action: replace, from: "^VIR_DOMAIN_JOB_OPERATION", to: "VIR_DOMAIN_JOB_OPERATION_STR"} + - {transform: lower} diff --git a/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf b/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf new file mode 100644 index 000000000..d416d7ba3 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/libvirtd.conf @@ -0,0 +1,7 @@ +# libvirtd configuration for travis-ci +listen_tls = 0 +listen_tcp = 1 +tcp_port = "16509" +listen_addr = "127.0.0.1" +auth_unix_rw = "none" +auth_tcp = "none" diff --git a/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go new file mode 100644 index 000000000..7666a63cd --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/qemu_protocol.gen.go @@ -0,0 +1,292 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +// Code generated by internal/lvgen/generate.go. DO NOT EDIT. +// +// To regenerate, run 'go generate' in internal/lvgen. +// + +package libvirt + +import ( + "bytes" + "io" + + "github.com/digitalocean/go-libvirt/internal/constants" + "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2" +) + +// References to prevent "imported and not used" errors. +var ( + _ = bytes.Buffer{} + _ = io.Copy + _ = constants.Program + _ = xdr.Unmarshal +) + +// +// Typedefs: +// + +// +// Enums: +// +// QEMUProcedure is libvirt's qemu_procedure +type QEMUProcedure int32 + +// +// Structs: +// +// QEMUDomainMonitorCommandArgs is libvirt's qemu_domain_monitor_command_args +type QEMUDomainMonitorCommandArgs struct { + Dom Domain + Cmd string + Flags uint32 +} + +// QEMUDomainMonitorCommandRet is libvirt's qemu_domain_monitor_command_ret +type QEMUDomainMonitorCommandRet struct { + Result string +} + +// QEMUDomainAttachArgs is libvirt's qemu_domain_attach_args +type QEMUDomainAttachArgs struct { + PidValue uint32 + Flags uint32 +} + +// QEMUDomainAttachRet is libvirt's qemu_domain_attach_ret +type QEMUDomainAttachRet struct { + Dom Domain +} + +// QEMUDomainAgentCommandArgs is libvirt's qemu_domain_agent_command_args +type QEMUDomainAgentCommandArgs struct { + Dom Domain + Cmd string + Timeout int32 + Flags uint32 +} + +// QEMUDomainAgentCommandRet is libvirt's qemu_domain_agent_command_ret +type QEMUDomainAgentCommandRet struct { + Result OptString +} + +// QEMUConnectDomainMonitorEventRegisterArgs is libvirt's qemu_connect_domain_monitor_event_register_args +type QEMUConnectDomainMonitorEventRegisterArgs struct { + Dom OptDomain + Event OptString + Flags uint32 +} + +// QEMUConnectDomainMonitorEventRegisterRet is libvirt's qemu_connect_domain_monitor_event_register_ret +type QEMUConnectDomainMonitorEventRegisterRet struct { + CallbackID int32 +} + +// QEMUConnectDomainMonitorEventDeregisterArgs is libvirt's qemu_connect_domain_monitor_event_deregister_args +type QEMUConnectDomainMonitorEventDeregisterArgs struct { + CallbackID int32 +} + +// QEMUDomainMonitorEventMsg is libvirt's qemu_domain_monitor_event_msg +type QEMUDomainMonitorEventMsg struct { + CallbackID int32 + Dom Domain + Event string + Seconds int64 + Micros uint32 + Details OptString +} + + + + +// QEMUDomainMonitorCommand is the go wrapper for QEMU_PROC_DOMAIN_MONITOR_COMMAND. +func (l *Libvirt) QEMUDomainMonitorCommand(Dom Domain, Cmd string, Flags uint32) (rResult string, err error) { + var buf []byte + + args := QEMUDomainMonitorCommandArgs { + Dom: Dom, + Cmd: Cmd, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(1, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: string + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// QEMUDomainAttach is the go wrapper for QEMU_PROC_DOMAIN_ATTACH. +func (l *Libvirt) QEMUDomainAttach(PidValue uint32, Flags uint32) (rDom Domain, err error) { + var buf []byte + + args := QEMUDomainAttachArgs { + PidValue: PidValue, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(2, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// QEMUDomainAgentCommand is the go wrapper for QEMU_PROC_DOMAIN_AGENT_COMMAND. +func (l *Libvirt) QEMUDomainAgentCommand(Dom Domain, Cmd string, Timeout int32, Flags uint32) (rResult OptString, err error) { + var buf []byte + + args := QEMUDomainAgentCommandArgs { + Dom: Dom, + Cmd: Cmd, + Timeout: Timeout, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(3, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: OptString + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// QEMUConnectDomainMonitorEventRegister is the go wrapper for QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER. +func (l *Libvirt) QEMUConnectDomainMonitorEventRegister(Dom OptDomain, Event OptString, Flags uint32) (rCallbackID int32, err error) { + var buf []byte + + args := QEMUConnectDomainMonitorEventRegisterArgs { + Dom: Dom, + Event: Event, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(4, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// QEMUConnectDomainMonitorEventDeregister is the go wrapper for QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER. +func (l *Libvirt) QEMUConnectDomainMonitorEventDeregister(CallbackID int32) (err error) { + var buf []byte + + args := QEMUConnectDomainMonitorEventDeregisterArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(5, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + return +} + +// QEMUDomainMonitorEvent is the go wrapper for QEMU_PROC_DOMAIN_MONITOR_EVENT. +func (l *Libvirt) QEMUDomainMonitorEvent() (err error) { + var buf []byte + + + _, err = l.requestStream(6, constants.QEMUProgram, buf, nil, nil) + if err != nil { + return + } + + return +} + diff --git a/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go b/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go new file mode 100644 index 000000000..0021e866e --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/remote_protocol.gen.go @@ -0,0 +1,16449 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +// Code generated by internal/lvgen/generate.go. DO NOT EDIT. +// +// To regenerate, run 'go generate' in internal/lvgen. +// + +package libvirt + +import ( + "bytes" + "io" + + "github.com/digitalocean/go-libvirt/internal/constants" + "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2" +) + +// References to prevent "imported and not used" errors. +var ( + _ = bytes.Buffer{} + _ = io.Copy + _ = constants.Program + _ = xdr.Unmarshal +) + +// +// Typedefs: +// +// OptString is libvirt's remote_string +type OptString []string +// UUID is libvirt's remote_uuid +type UUID [UUIDBuflen]byte +// OptDomain is libvirt's remote_domain +type OptDomain []Domain +// OptNetwork is libvirt's remote_network +type OptNetwork []Network +// OptNetworkPort is libvirt's remote_network_port +type OptNetworkPort []NetworkPort +// OptNwfilter is libvirt's remote_nwfilter +type OptNwfilter []Nwfilter +// OptNwfilterBinding is libvirt's remote_nwfilter_binding +type OptNwfilterBinding []NwfilterBinding +// OptStoragePool is libvirt's remote_storage_pool +type OptStoragePool []StoragePool +// OptStorageVol is libvirt's remote_storage_vol +type OptStorageVol []StorageVol +// OptNodeDevice is libvirt's remote_node_device +type OptNodeDevice []NodeDevice +// OptSecret is libvirt's remote_secret +type OptSecret []Secret + +// +// Enums: +// +// AuthType is libvirt's remote_auth_type +type AuthType int32 +// Procedure is libvirt's remote_procedure +type Procedure int32 + +// +// Structs: +// +// Domain is libvirt's remote_nonnull_domain +type Domain struct { + Name string + UUID UUID + ID int32 +} + +// Network is libvirt's remote_nonnull_network +type Network struct { + Name string + UUID UUID +} + +// NetworkPort is libvirt's remote_nonnull_network_port +type NetworkPort struct { + Net Network + UUID UUID +} + +// Nwfilter is libvirt's remote_nonnull_nwfilter +type Nwfilter struct { + Name string + UUID UUID +} + +// NwfilterBinding is libvirt's remote_nonnull_nwfilter_binding +type NwfilterBinding struct { + Portdev string + Filtername string +} + +// Interface is libvirt's remote_nonnull_interface +type Interface struct { + Name string + Mac string +} + +// StoragePool is libvirt's remote_nonnull_storage_pool +type StoragePool struct { + Name string + UUID UUID +} + +// StorageVol is libvirt's remote_nonnull_storage_vol +type StorageVol struct { + Pool string + Name string + Key string +} + +// NodeDevice is libvirt's remote_nonnull_node_device +type NodeDevice struct { + Name string +} + +// Secret is libvirt's remote_nonnull_secret +type Secret struct { + UUID UUID + UsageType int32 + UsageID string +} + +// DomainCheckpoint is libvirt's remote_nonnull_domain_checkpoint +type DomainCheckpoint struct { + Name string + Dom Domain +} + +// DomainSnapshot is libvirt's remote_nonnull_domain_snapshot +type DomainSnapshot struct { + Name string + Dom Domain +} + +// Error is libvirt's remote_error +type Error struct { + Code int32 + OptDomain int32 + Message OptString + Level int32 + Dom OptDomain + Str1 OptString + Str2 OptString + Str3 OptString + Int1 int32 + Int2 int32 + Net OptNetwork +} + +// VcpuInfo is libvirt's remote_vcpu_info +type VcpuInfo struct { + Number uint32 + State int32 + CPUTime uint64 + CPU int32 +} + +// TypedParam is libvirt's remote_typed_param +type TypedParam struct { + Field string + Value TypedParamValue +} + +// NodeGetCPUStats is libvirt's remote_node_get_cpu_stats +type NodeGetCPUStats struct { + Field string + Value uint64 +} + +// NodeGetMemoryStats is libvirt's remote_node_get_memory_stats +type NodeGetMemoryStats struct { + Field string + Value uint64 +} + +// DomainDiskError is libvirt's remote_domain_disk_error +type DomainDiskError struct { + Disk string + Error int32 +} + +// ConnectOpenArgs is libvirt's remote_connect_open_args +type ConnectOpenArgs struct { + Name OptString + Flags ConnectFlags +} + +// ConnectSupportsFeatureArgs is libvirt's remote_connect_supports_feature_args +type ConnectSupportsFeatureArgs struct { + Feature int32 +} + +// ConnectSupportsFeatureRet is libvirt's remote_connect_supports_feature_ret +type ConnectSupportsFeatureRet struct { + Supported int32 +} + +// ConnectGetTypeRet is libvirt's remote_connect_get_type_ret +type ConnectGetTypeRet struct { + Type string +} + +// ConnectGetVersionRet is libvirt's remote_connect_get_version_ret +type ConnectGetVersionRet struct { + HvVer uint64 +} + +// ConnectGetLibVersionRet is libvirt's remote_connect_get_lib_version_ret +type ConnectGetLibVersionRet struct { + LibVer uint64 +} + +// ConnectGetHostnameRet is libvirt's remote_connect_get_hostname_ret +type ConnectGetHostnameRet struct { + Hostname string +} + +// ConnectGetSysinfoArgs is libvirt's remote_connect_get_sysinfo_args +type ConnectGetSysinfoArgs struct { + Flags uint32 +} + +// ConnectGetSysinfoRet is libvirt's remote_connect_get_sysinfo_ret +type ConnectGetSysinfoRet struct { + Sysinfo string +} + +// ConnectGetUriRet is libvirt's remote_connect_get_uri_ret +type ConnectGetUriRet struct { + Uri string +} + +// ConnectGetMaxVcpusArgs is libvirt's remote_connect_get_max_vcpus_args +type ConnectGetMaxVcpusArgs struct { + Type OptString +} + +// ConnectGetMaxVcpusRet is libvirt's remote_connect_get_max_vcpus_ret +type ConnectGetMaxVcpusRet struct { + MaxVcpus int32 +} + +// NodeGetInfoRet is libvirt's remote_node_get_info_ret +type NodeGetInfoRet struct { + Model [32]int8 + Memory uint64 + Cpus int32 + Mhz int32 + Nodes int32 + Sockets int32 + Cores int32 + Threads int32 +} + +// ConnectGetCapabilitiesRet is libvirt's remote_connect_get_capabilities_ret +type ConnectGetCapabilitiesRet struct { + Capabilities string +} + +// ConnectGetDomainCapabilitiesArgs is libvirt's remote_connect_get_domain_capabilities_args +type ConnectGetDomainCapabilitiesArgs struct { + Emulatorbin OptString + Arch OptString + Machine OptString + Virttype OptString + Flags uint32 +} + +// ConnectGetDomainCapabilitiesRet is libvirt's remote_connect_get_domain_capabilities_ret +type ConnectGetDomainCapabilitiesRet struct { + Capabilities string +} + +// NodeGetCPUStatsArgs is libvirt's remote_node_get_cpu_stats_args +type NodeGetCPUStatsArgs struct { + CPUNum int32 + Nparams int32 + Flags uint32 +} + +// NodeGetCPUStatsRet is libvirt's remote_node_get_cpu_stats_ret +type NodeGetCPUStatsRet struct { + Params []NodeGetCPUStats + Nparams int32 +} + +// NodeGetMemoryStatsArgs is libvirt's remote_node_get_memory_stats_args +type NodeGetMemoryStatsArgs struct { + Nparams int32 + CellNum int32 + Flags uint32 +} + +// NodeGetMemoryStatsRet is libvirt's remote_node_get_memory_stats_ret +type NodeGetMemoryStatsRet struct { + Params []NodeGetMemoryStats + Nparams int32 +} + +// NodeGetCellsFreeMemoryArgs is libvirt's remote_node_get_cells_free_memory_args +type NodeGetCellsFreeMemoryArgs struct { + StartCell int32 + Maxcells int32 +} + +// NodeGetCellsFreeMemoryRet is libvirt's remote_node_get_cells_free_memory_ret +type NodeGetCellsFreeMemoryRet struct { + Cells []uint64 +} + +// NodeGetFreeMemoryRet is libvirt's remote_node_get_free_memory_ret +type NodeGetFreeMemoryRet struct { + FreeMem uint64 +} + +// DomainGetSchedulerTypeArgs is libvirt's remote_domain_get_scheduler_type_args +type DomainGetSchedulerTypeArgs struct { + Dom Domain +} + +// DomainGetSchedulerTypeRet is libvirt's remote_domain_get_scheduler_type_ret +type DomainGetSchedulerTypeRet struct { + Type string + Nparams int32 +} + +// DomainGetSchedulerParametersArgs is libvirt's remote_domain_get_scheduler_parameters_args +type DomainGetSchedulerParametersArgs struct { + Dom Domain + Nparams int32 +} + +// DomainGetSchedulerParametersRet is libvirt's remote_domain_get_scheduler_parameters_ret +type DomainGetSchedulerParametersRet struct { + Params []TypedParam +} + +// DomainGetSchedulerParametersFlagsArgs is libvirt's remote_domain_get_scheduler_parameters_flags_args +type DomainGetSchedulerParametersFlagsArgs struct { + Dom Domain + Nparams int32 + Flags uint32 +} + +// DomainGetSchedulerParametersFlagsRet is libvirt's remote_domain_get_scheduler_parameters_flags_ret +type DomainGetSchedulerParametersFlagsRet struct { + Params []TypedParam +} + +// DomainSetSchedulerParametersArgs is libvirt's remote_domain_set_scheduler_parameters_args +type DomainSetSchedulerParametersArgs struct { + Dom Domain + Params []TypedParam +} + +// DomainSetSchedulerParametersFlagsArgs is libvirt's remote_domain_set_scheduler_parameters_flags_args +type DomainSetSchedulerParametersFlagsArgs struct { + Dom Domain + Params []TypedParam + Flags uint32 +} + +// DomainSetBlkioParametersArgs is libvirt's remote_domain_set_blkio_parameters_args +type DomainSetBlkioParametersArgs struct { + Dom Domain + Params []TypedParam + Flags uint32 +} + +// DomainGetBlkioParametersArgs is libvirt's remote_domain_get_blkio_parameters_args +type DomainGetBlkioParametersArgs struct { + Dom Domain + Nparams int32 + Flags uint32 +} + +// DomainGetBlkioParametersRet is libvirt's remote_domain_get_blkio_parameters_ret +type DomainGetBlkioParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainSetMemoryParametersArgs is libvirt's remote_domain_set_memory_parameters_args +type DomainSetMemoryParametersArgs struct { + Dom Domain + Params []TypedParam + Flags uint32 +} + +// DomainGetMemoryParametersArgs is libvirt's remote_domain_get_memory_parameters_args +type DomainGetMemoryParametersArgs struct { + Dom Domain + Nparams int32 + Flags uint32 +} + +// DomainGetMemoryParametersRet is libvirt's remote_domain_get_memory_parameters_ret +type DomainGetMemoryParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainBlockResizeArgs is libvirt's remote_domain_block_resize_args +type DomainBlockResizeArgs struct { + Dom Domain + Disk string + Size uint64 + Flags DomainBlockResizeFlags +} + +// DomainSetNumaParametersArgs is libvirt's remote_domain_set_numa_parameters_args +type DomainSetNumaParametersArgs struct { + Dom Domain + Params []TypedParam + Flags uint32 +} + +// DomainGetNumaParametersArgs is libvirt's remote_domain_get_numa_parameters_args +type DomainGetNumaParametersArgs struct { + Dom Domain + Nparams int32 + Flags uint32 +} + +// DomainGetNumaParametersRet is libvirt's remote_domain_get_numa_parameters_ret +type DomainGetNumaParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainSetPerfEventsArgs is libvirt's remote_domain_set_perf_events_args +type DomainSetPerfEventsArgs struct { + Dom Domain + Params []TypedParam + Flags DomainModificationImpact +} + +// DomainGetPerfEventsArgs is libvirt's remote_domain_get_perf_events_args +type DomainGetPerfEventsArgs struct { + Dom Domain + Flags DomainModificationImpact +} + +// DomainGetPerfEventsRet is libvirt's remote_domain_get_perf_events_ret +type DomainGetPerfEventsRet struct { + Params []TypedParam +} + +// DomainBlockStatsArgs is libvirt's remote_domain_block_stats_args +type DomainBlockStatsArgs struct { + Dom Domain + Path string +} + +// DomainBlockStatsRet is libvirt's remote_domain_block_stats_ret +type DomainBlockStatsRet struct { + RdReq int64 + RdBytes int64 + WrReq int64 + WrBytes int64 + Errs int64 +} + +// DomainBlockStatsFlagsArgs is libvirt's remote_domain_block_stats_flags_args +type DomainBlockStatsFlagsArgs struct { + Dom Domain + Path string + Nparams int32 + Flags uint32 +} + +// DomainBlockStatsFlagsRet is libvirt's remote_domain_block_stats_flags_ret +type DomainBlockStatsFlagsRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainInterfaceStatsArgs is libvirt's remote_domain_interface_stats_args +type DomainInterfaceStatsArgs struct { + Dom Domain + Device string +} + +// DomainInterfaceStatsRet is libvirt's remote_domain_interface_stats_ret +type DomainInterfaceStatsRet struct { + RxBytes int64 + RxPackets int64 + RxErrs int64 + RxDrop int64 + TxBytes int64 + TxPackets int64 + TxErrs int64 + TxDrop int64 +} + +// DomainSetInterfaceParametersArgs is libvirt's remote_domain_set_interface_parameters_args +type DomainSetInterfaceParametersArgs struct { + Dom Domain + Device string + Params []TypedParam + Flags uint32 +} + +// DomainGetInterfaceParametersArgs is libvirt's remote_domain_get_interface_parameters_args +type DomainGetInterfaceParametersArgs struct { + Dom Domain + Device string + Nparams int32 + Flags DomainModificationImpact +} + +// DomainGetInterfaceParametersRet is libvirt's remote_domain_get_interface_parameters_ret +type DomainGetInterfaceParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainMemoryStatsArgs is libvirt's remote_domain_memory_stats_args +type DomainMemoryStatsArgs struct { + Dom Domain + MaxStats uint32 + Flags uint32 +} + +// DomainMemoryStat is libvirt's remote_domain_memory_stat +type DomainMemoryStat struct { + Tag int32 + Val uint64 +} + +// DomainMemoryStatsRet is libvirt's remote_domain_memory_stats_ret +type DomainMemoryStatsRet struct { + Stats []DomainMemoryStat +} + +// DomainBlockPeekArgs is libvirt's remote_domain_block_peek_args +type DomainBlockPeekArgs struct { + Dom Domain + Path string + Offset uint64 + Size uint32 + Flags uint32 +} + +// DomainBlockPeekRet is libvirt's remote_domain_block_peek_ret +type DomainBlockPeekRet struct { + Buffer []byte +} + +// DomainMemoryPeekArgs is libvirt's remote_domain_memory_peek_args +type DomainMemoryPeekArgs struct { + Dom Domain + Offset uint64 + Size uint32 + Flags DomainMemoryFlags +} + +// DomainMemoryPeekRet is libvirt's remote_domain_memory_peek_ret +type DomainMemoryPeekRet struct { + Buffer []byte +} + +// DomainGetBlockInfoArgs is libvirt's remote_domain_get_block_info_args +type DomainGetBlockInfoArgs struct { + Dom Domain + Path string + Flags uint32 +} + +// DomainGetBlockInfoRet is libvirt's remote_domain_get_block_info_ret +type DomainGetBlockInfoRet struct { + Allocation uint64 + Capacity uint64 + Physical uint64 +} + +// ConnectListDomainsArgs is libvirt's remote_connect_list_domains_args +type ConnectListDomainsArgs struct { + Maxids int32 +} + +// ConnectListDomainsRet is libvirt's remote_connect_list_domains_ret +type ConnectListDomainsRet struct { + Ids []int32 +} + +// ConnectNumOfDomainsRet is libvirt's remote_connect_num_of_domains_ret +type ConnectNumOfDomainsRet struct { + Num int32 +} + +// DomainCreateXMLArgs is libvirt's remote_domain_create_xml_args +type DomainCreateXMLArgs struct { + XMLDesc string + Flags DomainCreateFlags +} + +// DomainCreateXMLRet is libvirt's remote_domain_create_xml_ret +type DomainCreateXMLRet struct { + Dom Domain +} + +// DomainCreateXMLWithFilesArgs is libvirt's remote_domain_create_xml_with_files_args +type DomainCreateXMLWithFilesArgs struct { + XMLDesc string + Flags DomainCreateFlags +} + +// DomainCreateXMLWithFilesRet is libvirt's remote_domain_create_xml_with_files_ret +type DomainCreateXMLWithFilesRet struct { + Dom Domain +} + +// DomainLookupByIDArgs is libvirt's remote_domain_lookup_by_id_args +type DomainLookupByIDArgs struct { + ID int32 +} + +// DomainLookupByIDRet is libvirt's remote_domain_lookup_by_id_ret +type DomainLookupByIDRet struct { + Dom Domain +} + +// DomainLookupByUUIDArgs is libvirt's remote_domain_lookup_by_uuid_args +type DomainLookupByUUIDArgs struct { + UUID UUID +} + +// DomainLookupByUUIDRet is libvirt's remote_domain_lookup_by_uuid_ret +type DomainLookupByUUIDRet struct { + Dom Domain +} + +// DomainLookupByNameArgs is libvirt's remote_domain_lookup_by_name_args +type DomainLookupByNameArgs struct { + Name string +} + +// DomainLookupByNameRet is libvirt's remote_domain_lookup_by_name_ret +type DomainLookupByNameRet struct { + Dom Domain +} + +// DomainSuspendArgs is libvirt's remote_domain_suspend_args +type DomainSuspendArgs struct { + Dom Domain +} + +// DomainResumeArgs is libvirt's remote_domain_resume_args +type DomainResumeArgs struct { + Dom Domain +} + +// DomainPmSuspendForDurationArgs is libvirt's remote_domain_pm_suspend_for_duration_args +type DomainPmSuspendForDurationArgs struct { + Dom Domain + Target uint32 + Duration uint64 + Flags uint32 +} + +// DomainPmWakeupArgs is libvirt's remote_domain_pm_wakeup_args +type DomainPmWakeupArgs struct { + Dom Domain + Flags uint32 +} + +// DomainShutdownArgs is libvirt's remote_domain_shutdown_args +type DomainShutdownArgs struct { + Dom Domain +} + +// DomainRebootArgs is libvirt's remote_domain_reboot_args +type DomainRebootArgs struct { + Dom Domain + Flags DomainRebootFlagValues +} + +// DomainResetArgs is libvirt's remote_domain_reset_args +type DomainResetArgs struct { + Dom Domain + Flags uint32 +} + +// DomainDestroyArgs is libvirt's remote_domain_destroy_args +type DomainDestroyArgs struct { + Dom Domain +} + +// DomainDestroyFlagsArgs is libvirt's remote_domain_destroy_flags_args +type DomainDestroyFlagsArgs struct { + Dom Domain + Flags DomainDestroyFlagsValues +} + +// DomainGetOsTypeArgs is libvirt's remote_domain_get_os_type_args +type DomainGetOsTypeArgs struct { + Dom Domain +} + +// DomainGetOsTypeRet is libvirt's remote_domain_get_os_type_ret +type DomainGetOsTypeRet struct { + Type string +} + +// DomainGetMaxMemoryArgs is libvirt's remote_domain_get_max_memory_args +type DomainGetMaxMemoryArgs struct { + Dom Domain +} + +// DomainGetMaxMemoryRet is libvirt's remote_domain_get_max_memory_ret +type DomainGetMaxMemoryRet struct { + Memory uint64 +} + +// DomainSetMaxMemoryArgs is libvirt's remote_domain_set_max_memory_args +type DomainSetMaxMemoryArgs struct { + Dom Domain + Memory uint64 +} + +// DomainSetMemoryArgs is libvirt's remote_domain_set_memory_args +type DomainSetMemoryArgs struct { + Dom Domain + Memory uint64 +} + +// DomainSetMemoryFlagsArgs is libvirt's remote_domain_set_memory_flags_args +type DomainSetMemoryFlagsArgs struct { + Dom Domain + Memory uint64 + Flags uint32 +} + +// DomainSetMemoryStatsPeriodArgs is libvirt's remote_domain_set_memory_stats_period_args +type DomainSetMemoryStatsPeriodArgs struct { + Dom Domain + Period int32 + Flags DomainMemoryModFlags +} + +// DomainGetInfoArgs is libvirt's remote_domain_get_info_args +type DomainGetInfoArgs struct { + Dom Domain +} + +// DomainGetInfoRet is libvirt's remote_domain_get_info_ret +type DomainGetInfoRet struct { + State uint8 + MaxMem uint64 + Memory uint64 + NrVirtCPU uint16 + CPUTime uint64 +} + +// DomainSaveArgs is libvirt's remote_domain_save_args +type DomainSaveArgs struct { + Dom Domain + To string +} + +// DomainSaveFlagsArgs is libvirt's remote_domain_save_flags_args +type DomainSaveFlagsArgs struct { + Dom Domain + To string + Dxml OptString + Flags uint32 +} + +// DomainRestoreArgs is libvirt's remote_domain_restore_args +type DomainRestoreArgs struct { + From string +} + +// DomainRestoreFlagsArgs is libvirt's remote_domain_restore_flags_args +type DomainRestoreFlagsArgs struct { + From string + Dxml OptString + Flags uint32 +} + +// DomainSaveImageGetXMLDescArgs is libvirt's remote_domain_save_image_get_xml_desc_args +type DomainSaveImageGetXMLDescArgs struct { + File string + Flags uint32 +} + +// DomainSaveImageGetXMLDescRet is libvirt's remote_domain_save_image_get_xml_desc_ret +type DomainSaveImageGetXMLDescRet struct { + XML string +} + +// DomainSaveImageDefineXMLArgs is libvirt's remote_domain_save_image_define_xml_args +type DomainSaveImageDefineXMLArgs struct { + File string + Dxml string + Flags uint32 +} + +// DomainCoreDumpArgs is libvirt's remote_domain_core_dump_args +type DomainCoreDumpArgs struct { + Dom Domain + To string + Flags DomainCoreDumpFlags +} + +// DomainCoreDumpWithFormatArgs is libvirt's remote_domain_core_dump_with_format_args +type DomainCoreDumpWithFormatArgs struct { + Dom Domain + To string + Dumpformat uint32 + Flags DomainCoreDumpFlags +} + +// DomainScreenshotArgs is libvirt's remote_domain_screenshot_args +type DomainScreenshotArgs struct { + Dom Domain + Screen uint32 + Flags uint32 +} + +// DomainScreenshotRet is libvirt's remote_domain_screenshot_ret +type DomainScreenshotRet struct { + Mime OptString +} + +// DomainGetXMLDescArgs is libvirt's remote_domain_get_xml_desc_args +type DomainGetXMLDescArgs struct { + Dom Domain + Flags DomainXMLFlags +} + +// DomainGetXMLDescRet is libvirt's remote_domain_get_xml_desc_ret +type DomainGetXMLDescRet struct { + XML string +} + +// DomainMigratePrepareArgs is libvirt's remote_domain_migrate_prepare_args +type DomainMigratePrepareArgs struct { + UriIn OptString + Flags uint64 + Dname OptString + Resource uint64 +} + +// DomainMigratePrepareRet is libvirt's remote_domain_migrate_prepare_ret +type DomainMigratePrepareRet struct { + Cookie []byte + UriOut OptString +} + +// DomainMigratePerformArgs is libvirt's remote_domain_migrate_perform_args +type DomainMigratePerformArgs struct { + Dom Domain + Cookie []byte + Uri string + Flags uint64 + Dname OptString + Resource uint64 +} + +// DomainMigrateFinishArgs is libvirt's remote_domain_migrate_finish_args +type DomainMigrateFinishArgs struct { + Dname string + Cookie []byte + Uri string + Flags uint64 +} + +// DomainMigrateFinishRet is libvirt's remote_domain_migrate_finish_ret +type DomainMigrateFinishRet struct { + Ddom Domain +} + +// DomainMigratePrepare2Args is libvirt's remote_domain_migrate_prepare2_args +type DomainMigratePrepare2Args struct { + UriIn OptString + Flags uint64 + Dname OptString + Resource uint64 + DomXML string +} + +// DomainMigratePrepare2Ret is libvirt's remote_domain_migrate_prepare2_ret +type DomainMigratePrepare2Ret struct { + Cookie []byte + UriOut OptString +} + +// DomainMigrateFinish2Args is libvirt's remote_domain_migrate_finish2_args +type DomainMigrateFinish2Args struct { + Dname string + Cookie []byte + Uri string + Flags uint64 + Retcode int32 +} + +// DomainMigrateFinish2Ret is libvirt's remote_domain_migrate_finish2_ret +type DomainMigrateFinish2Ret struct { + Ddom Domain +} + +// ConnectListDefinedDomainsArgs is libvirt's remote_connect_list_defined_domains_args +type ConnectListDefinedDomainsArgs struct { + Maxnames int32 +} + +// ConnectListDefinedDomainsRet is libvirt's remote_connect_list_defined_domains_ret +type ConnectListDefinedDomainsRet struct { + Names []string +} + +// ConnectNumOfDefinedDomainsRet is libvirt's remote_connect_num_of_defined_domains_ret +type ConnectNumOfDefinedDomainsRet struct { + Num int32 +} + +// DomainCreateArgs is libvirt's remote_domain_create_args +type DomainCreateArgs struct { + Dom Domain +} + +// DomainCreateWithFlagsArgs is libvirt's remote_domain_create_with_flags_args +type DomainCreateWithFlagsArgs struct { + Dom Domain + Flags uint32 +} + +// DomainCreateWithFlagsRet is libvirt's remote_domain_create_with_flags_ret +type DomainCreateWithFlagsRet struct { + Dom Domain +} + +// DomainCreateWithFilesArgs is libvirt's remote_domain_create_with_files_args +type DomainCreateWithFilesArgs struct { + Dom Domain + Flags DomainCreateFlags +} + +// DomainCreateWithFilesRet is libvirt's remote_domain_create_with_files_ret +type DomainCreateWithFilesRet struct { + Dom Domain +} + +// DomainDefineXMLArgs is libvirt's remote_domain_define_xml_args +type DomainDefineXMLArgs struct { + XML string +} + +// DomainDefineXMLRet is libvirt's remote_domain_define_xml_ret +type DomainDefineXMLRet struct { + Dom Domain +} + +// DomainDefineXMLFlagsArgs is libvirt's remote_domain_define_xml_flags_args +type DomainDefineXMLFlagsArgs struct { + XML string + Flags DomainDefineFlags +} + +// DomainDefineXMLFlagsRet is libvirt's remote_domain_define_xml_flags_ret +type DomainDefineXMLFlagsRet struct { + Dom Domain +} + +// DomainUndefineArgs is libvirt's remote_domain_undefine_args +type DomainUndefineArgs struct { + Dom Domain +} + +// DomainUndefineFlagsArgs is libvirt's remote_domain_undefine_flags_args +type DomainUndefineFlagsArgs struct { + Dom Domain + Flags DomainUndefineFlagsValues +} + +// DomainInjectNmiArgs is libvirt's remote_domain_inject_nmi_args +type DomainInjectNmiArgs struct { + Dom Domain + Flags uint32 +} + +// DomainSendKeyArgs is libvirt's remote_domain_send_key_args +type DomainSendKeyArgs struct { + Dom Domain + Codeset uint32 + Holdtime uint32 + Keycodes []uint32 + Flags uint32 +} + +// DomainSendProcessSignalArgs is libvirt's remote_domain_send_process_signal_args +type DomainSendProcessSignalArgs struct { + Dom Domain + PidValue int64 + Signum uint32 + Flags uint32 +} + +// DomainSetVcpusArgs is libvirt's remote_domain_set_vcpus_args +type DomainSetVcpusArgs struct { + Dom Domain + Nvcpus uint32 +} + +// DomainSetVcpusFlagsArgs is libvirt's remote_domain_set_vcpus_flags_args +type DomainSetVcpusFlagsArgs struct { + Dom Domain + Nvcpus uint32 + Flags uint32 +} + +// DomainGetVcpusFlagsArgs is libvirt's remote_domain_get_vcpus_flags_args +type DomainGetVcpusFlagsArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetVcpusFlagsRet is libvirt's remote_domain_get_vcpus_flags_ret +type DomainGetVcpusFlagsRet struct { + Num int32 +} + +// DomainPinVcpuArgs is libvirt's remote_domain_pin_vcpu_args +type DomainPinVcpuArgs struct { + Dom Domain + Vcpu uint32 + Cpumap []byte +} + +// DomainPinVcpuFlagsArgs is libvirt's remote_domain_pin_vcpu_flags_args +type DomainPinVcpuFlagsArgs struct { + Dom Domain + Vcpu uint32 + Cpumap []byte + Flags uint32 +} + +// DomainGetVcpuPinInfoArgs is libvirt's remote_domain_get_vcpu_pin_info_args +type DomainGetVcpuPinInfoArgs struct { + Dom Domain + Ncpumaps int32 + Maplen int32 + Flags uint32 +} + +// DomainGetVcpuPinInfoRet is libvirt's remote_domain_get_vcpu_pin_info_ret +type DomainGetVcpuPinInfoRet struct { + Cpumaps []byte + Num int32 +} + +// DomainPinEmulatorArgs is libvirt's remote_domain_pin_emulator_args +type DomainPinEmulatorArgs struct { + Dom Domain + Cpumap []byte + Flags DomainModificationImpact +} + +// DomainGetEmulatorPinInfoArgs is libvirt's remote_domain_get_emulator_pin_info_args +type DomainGetEmulatorPinInfoArgs struct { + Dom Domain + Maplen int32 + Flags DomainModificationImpact +} + +// DomainGetEmulatorPinInfoRet is libvirt's remote_domain_get_emulator_pin_info_ret +type DomainGetEmulatorPinInfoRet struct { + Cpumaps []byte + Ret int32 +} + +// DomainGetVcpusArgs is libvirt's remote_domain_get_vcpus_args +type DomainGetVcpusArgs struct { + Dom Domain + Maxinfo int32 + Maplen int32 +} + +// DomainGetVcpusRet is libvirt's remote_domain_get_vcpus_ret +type DomainGetVcpusRet struct { + Info []VcpuInfo + Cpumaps []byte +} + +// DomainGetMaxVcpusArgs is libvirt's remote_domain_get_max_vcpus_args +type DomainGetMaxVcpusArgs struct { + Dom Domain +} + +// DomainGetMaxVcpusRet is libvirt's remote_domain_get_max_vcpus_ret +type DomainGetMaxVcpusRet struct { + Num int32 +} + +// DomainIothreadInfo is libvirt's remote_domain_iothread_info +type DomainIothreadInfo struct { + IothreadID uint32 + Cpumap []byte +} + +// DomainGetIothreadInfoArgs is libvirt's remote_domain_get_iothread_info_args +type DomainGetIothreadInfoArgs struct { + Dom Domain + Flags DomainModificationImpact +} + +// DomainGetIothreadInfoRet is libvirt's remote_domain_get_iothread_info_ret +type DomainGetIothreadInfoRet struct { + Info []DomainIothreadInfo + Ret uint32 +} + +// DomainPinIothreadArgs is libvirt's remote_domain_pin_iothread_args +type DomainPinIothreadArgs struct { + Dom Domain + IothreadsID uint32 + Cpumap []byte + Flags DomainModificationImpact +} + +// DomainAddIothreadArgs is libvirt's remote_domain_add_iothread_args +type DomainAddIothreadArgs struct { + Dom Domain + IothreadID uint32 + Flags DomainModificationImpact +} + +// DomainDelIothreadArgs is libvirt's remote_domain_del_iothread_args +type DomainDelIothreadArgs struct { + Dom Domain + IothreadID uint32 + Flags DomainModificationImpact +} + +// DomainSetIothreadParamsArgs is libvirt's remote_domain_set_iothread_params_args +type DomainSetIothreadParamsArgs struct { + Dom Domain + IothreadID uint32 + Params []TypedParam + Flags uint32 +} + +// DomainGetSecurityLabelArgs is libvirt's remote_domain_get_security_label_args +type DomainGetSecurityLabelArgs struct { + Dom Domain +} + +// DomainGetSecurityLabelRet is libvirt's remote_domain_get_security_label_ret +type DomainGetSecurityLabelRet struct { + Label []int8 + Enforcing int32 +} + +// DomainGetSecurityLabelListArgs is libvirt's remote_domain_get_security_label_list_args +type DomainGetSecurityLabelListArgs struct { + Dom Domain +} + +// DomainGetSecurityLabelListRet is libvirt's remote_domain_get_security_label_list_ret +type DomainGetSecurityLabelListRet struct { + Labels []DomainGetSecurityLabelRet + Ret int32 +} + +// NodeGetSecurityModelRet is libvirt's remote_node_get_security_model_ret +type NodeGetSecurityModelRet struct { + Model []int8 + Doi []int8 +} + +// DomainAttachDeviceArgs is libvirt's remote_domain_attach_device_args +type DomainAttachDeviceArgs struct { + Dom Domain + XML string +} + +// DomainAttachDeviceFlagsArgs is libvirt's remote_domain_attach_device_flags_args +type DomainAttachDeviceFlagsArgs struct { + Dom Domain + XML string + Flags uint32 +} + +// DomainDetachDeviceArgs is libvirt's remote_domain_detach_device_args +type DomainDetachDeviceArgs struct { + Dom Domain + XML string +} + +// DomainDetachDeviceFlagsArgs is libvirt's remote_domain_detach_device_flags_args +type DomainDetachDeviceFlagsArgs struct { + Dom Domain + XML string + Flags uint32 +} + +// DomainUpdateDeviceFlagsArgs is libvirt's remote_domain_update_device_flags_args +type DomainUpdateDeviceFlagsArgs struct { + Dom Domain + XML string + Flags DomainDeviceModifyFlags +} + +// DomainDetachDeviceAliasArgs is libvirt's remote_domain_detach_device_alias_args +type DomainDetachDeviceAliasArgs struct { + Dom Domain + Alias string + Flags uint32 +} + +// DomainGetAutostartArgs is libvirt's remote_domain_get_autostart_args +type DomainGetAutostartArgs struct { + Dom Domain +} + +// DomainGetAutostartRet is libvirt's remote_domain_get_autostart_ret +type DomainGetAutostartRet struct { + Autostart int32 +} + +// DomainSetAutostartArgs is libvirt's remote_domain_set_autostart_args +type DomainSetAutostartArgs struct { + Dom Domain + Autostart int32 +} + +// DomainSetMetadataArgs is libvirt's remote_domain_set_metadata_args +type DomainSetMetadataArgs struct { + Dom Domain + Type int32 + Metadata OptString + Key OptString + Uri OptString + Flags DomainModificationImpact +} + +// DomainGetMetadataArgs is libvirt's remote_domain_get_metadata_args +type DomainGetMetadataArgs struct { + Dom Domain + Type int32 + Uri OptString + Flags DomainModificationImpact +} + +// DomainGetMetadataRet is libvirt's remote_domain_get_metadata_ret +type DomainGetMetadataRet struct { + Metadata string +} + +// DomainBlockJobAbortArgs is libvirt's remote_domain_block_job_abort_args +type DomainBlockJobAbortArgs struct { + Dom Domain + Path string + Flags DomainBlockJobAbortFlags +} + +// DomainGetBlockJobInfoArgs is libvirt's remote_domain_get_block_job_info_args +type DomainGetBlockJobInfoArgs struct { + Dom Domain + Path string + Flags uint32 +} + +// DomainGetBlockJobInfoRet is libvirt's remote_domain_get_block_job_info_ret +type DomainGetBlockJobInfoRet struct { + Found int32 + Type int32 + Bandwidth uint64 + Cur uint64 + End uint64 +} + +// DomainBlockJobSetSpeedArgs is libvirt's remote_domain_block_job_set_speed_args +type DomainBlockJobSetSpeedArgs struct { + Dom Domain + Path string + Bandwidth uint64 + Flags DomainBlockJobSetSpeedFlags +} + +// DomainBlockPullArgs is libvirt's remote_domain_block_pull_args +type DomainBlockPullArgs struct { + Dom Domain + Path string + Bandwidth uint64 + Flags DomainBlockPullFlags +} + +// DomainBlockRebaseArgs is libvirt's remote_domain_block_rebase_args +type DomainBlockRebaseArgs struct { + Dom Domain + Path string + Base OptString + Bandwidth uint64 + Flags DomainBlockRebaseFlags +} + +// DomainBlockCopyArgs is libvirt's remote_domain_block_copy_args +type DomainBlockCopyArgs struct { + Dom Domain + Path string + Destxml string + Params []TypedParam + Flags DomainBlockCopyFlags +} + +// DomainBlockCommitArgs is libvirt's remote_domain_block_commit_args +type DomainBlockCommitArgs struct { + Dom Domain + Disk string + Base OptString + Top OptString + Bandwidth uint64 + Flags DomainBlockCommitFlags +} + +// DomainSetBlockIOTuneArgs is libvirt's remote_domain_set_block_io_tune_args +type DomainSetBlockIOTuneArgs struct { + Dom Domain + Disk string + Params []TypedParam + Flags uint32 +} + +// DomainGetBlockIOTuneArgs is libvirt's remote_domain_get_block_io_tune_args +type DomainGetBlockIOTuneArgs struct { + Dom Domain + Disk OptString + Nparams int32 + Flags uint32 +} + +// DomainGetBlockIOTuneRet is libvirt's remote_domain_get_block_io_tune_ret +type DomainGetBlockIOTuneRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainGetCPUStatsArgs is libvirt's remote_domain_get_cpu_stats_args +type DomainGetCPUStatsArgs struct { + Dom Domain + Nparams uint32 + StartCPU int32 + Ncpus uint32 + Flags TypedParameterFlags +} + +// DomainGetCPUStatsRet is libvirt's remote_domain_get_cpu_stats_ret +type DomainGetCPUStatsRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainGetHostnameArgs is libvirt's remote_domain_get_hostname_args +type DomainGetHostnameArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetHostnameRet is libvirt's remote_domain_get_hostname_ret +type DomainGetHostnameRet struct { + Hostname string +} + +// ConnectNumOfNetworksRet is libvirt's remote_connect_num_of_networks_ret +type ConnectNumOfNetworksRet struct { + Num int32 +} + +// ConnectListNetworksArgs is libvirt's remote_connect_list_networks_args +type ConnectListNetworksArgs struct { + Maxnames int32 +} + +// ConnectListNetworksRet is libvirt's remote_connect_list_networks_ret +type ConnectListNetworksRet struct { + Names []string +} + +// ConnectNumOfDefinedNetworksRet is libvirt's remote_connect_num_of_defined_networks_ret +type ConnectNumOfDefinedNetworksRet struct { + Num int32 +} + +// ConnectListDefinedNetworksArgs is libvirt's remote_connect_list_defined_networks_args +type ConnectListDefinedNetworksArgs struct { + Maxnames int32 +} + +// ConnectListDefinedNetworksRet is libvirt's remote_connect_list_defined_networks_ret +type ConnectListDefinedNetworksRet struct { + Names []string +} + +// NetworkLookupByUUIDArgs is libvirt's remote_network_lookup_by_uuid_args +type NetworkLookupByUUIDArgs struct { + UUID UUID +} + +// NetworkLookupByUUIDRet is libvirt's remote_network_lookup_by_uuid_ret +type NetworkLookupByUUIDRet struct { + Net Network +} + +// NetworkLookupByNameArgs is libvirt's remote_network_lookup_by_name_args +type NetworkLookupByNameArgs struct { + Name string +} + +// NetworkLookupByNameRet is libvirt's remote_network_lookup_by_name_ret +type NetworkLookupByNameRet struct { + Net Network +} + +// NetworkCreateXMLArgs is libvirt's remote_network_create_xml_args +type NetworkCreateXMLArgs struct { + XML string +} + +// NetworkCreateXMLRet is libvirt's remote_network_create_xml_ret +type NetworkCreateXMLRet struct { + Net Network +} + +// NetworkDefineXMLArgs is libvirt's remote_network_define_xml_args +type NetworkDefineXMLArgs struct { + XML string +} + +// NetworkDefineXMLRet is libvirt's remote_network_define_xml_ret +type NetworkDefineXMLRet struct { + Net Network +} + +// NetworkUndefineArgs is libvirt's remote_network_undefine_args +type NetworkUndefineArgs struct { + Net Network +} + +// NetworkUpdateArgs is libvirt's remote_network_update_args +type NetworkUpdateArgs struct { + Net Network + Command uint32 + Section uint32 + ParentIndex int32 + XML string + Flags NetworkUpdateFlags +} + +// NetworkCreateArgs is libvirt's remote_network_create_args +type NetworkCreateArgs struct { + Net Network +} + +// NetworkDestroyArgs is libvirt's remote_network_destroy_args +type NetworkDestroyArgs struct { + Net Network +} + +// NetworkGetXMLDescArgs is libvirt's remote_network_get_xml_desc_args +type NetworkGetXMLDescArgs struct { + Net Network + Flags uint32 +} + +// NetworkGetXMLDescRet is libvirt's remote_network_get_xml_desc_ret +type NetworkGetXMLDescRet struct { + XML string +} + +// NetworkGetBridgeNameArgs is libvirt's remote_network_get_bridge_name_args +type NetworkGetBridgeNameArgs struct { + Net Network +} + +// NetworkGetBridgeNameRet is libvirt's remote_network_get_bridge_name_ret +type NetworkGetBridgeNameRet struct { + Name string +} + +// NetworkGetAutostartArgs is libvirt's remote_network_get_autostart_args +type NetworkGetAutostartArgs struct { + Net Network +} + +// NetworkGetAutostartRet is libvirt's remote_network_get_autostart_ret +type NetworkGetAutostartRet struct { + Autostart int32 +} + +// NetworkSetAutostartArgs is libvirt's remote_network_set_autostart_args +type NetworkSetAutostartArgs struct { + Net Network + Autostart int32 +} + +// ConnectNumOfNwfiltersRet is libvirt's remote_connect_num_of_nwfilters_ret +type ConnectNumOfNwfiltersRet struct { + Num int32 +} + +// ConnectListNwfiltersArgs is libvirt's remote_connect_list_nwfilters_args +type ConnectListNwfiltersArgs struct { + Maxnames int32 +} + +// ConnectListNwfiltersRet is libvirt's remote_connect_list_nwfilters_ret +type ConnectListNwfiltersRet struct { + Names []string +} + +// NwfilterLookupByUUIDArgs is libvirt's remote_nwfilter_lookup_by_uuid_args +type NwfilterLookupByUUIDArgs struct { + UUID UUID +} + +// NwfilterLookupByUUIDRet is libvirt's remote_nwfilter_lookup_by_uuid_ret +type NwfilterLookupByUUIDRet struct { + OptNwfilter Nwfilter +} + +// NwfilterLookupByNameArgs is libvirt's remote_nwfilter_lookup_by_name_args +type NwfilterLookupByNameArgs struct { + Name string +} + +// NwfilterLookupByNameRet is libvirt's remote_nwfilter_lookup_by_name_ret +type NwfilterLookupByNameRet struct { + OptNwfilter Nwfilter +} + +// NwfilterDefineXMLArgs is libvirt's remote_nwfilter_define_xml_args +type NwfilterDefineXMLArgs struct { + XML string +} + +// NwfilterDefineXMLRet is libvirt's remote_nwfilter_define_xml_ret +type NwfilterDefineXMLRet struct { + OptNwfilter Nwfilter +} + +// NwfilterUndefineArgs is libvirt's remote_nwfilter_undefine_args +type NwfilterUndefineArgs struct { + OptNwfilter Nwfilter +} + +// NwfilterGetXMLDescArgs is libvirt's remote_nwfilter_get_xml_desc_args +type NwfilterGetXMLDescArgs struct { + OptNwfilter Nwfilter + Flags uint32 +} + +// NwfilterGetXMLDescRet is libvirt's remote_nwfilter_get_xml_desc_ret +type NwfilterGetXMLDescRet struct { + XML string +} + +// ConnectNumOfInterfacesRet is libvirt's remote_connect_num_of_interfaces_ret +type ConnectNumOfInterfacesRet struct { + Num int32 +} + +// ConnectListInterfacesArgs is libvirt's remote_connect_list_interfaces_args +type ConnectListInterfacesArgs struct { + Maxnames int32 +} + +// ConnectListInterfacesRet is libvirt's remote_connect_list_interfaces_ret +type ConnectListInterfacesRet struct { + Names []string +} + +// ConnectNumOfDefinedInterfacesRet is libvirt's remote_connect_num_of_defined_interfaces_ret +type ConnectNumOfDefinedInterfacesRet struct { + Num int32 +} + +// ConnectListDefinedInterfacesArgs is libvirt's remote_connect_list_defined_interfaces_args +type ConnectListDefinedInterfacesArgs struct { + Maxnames int32 +} + +// ConnectListDefinedInterfacesRet is libvirt's remote_connect_list_defined_interfaces_ret +type ConnectListDefinedInterfacesRet struct { + Names []string +} + +// InterfaceLookupByNameArgs is libvirt's remote_interface_lookup_by_name_args +type InterfaceLookupByNameArgs struct { + Name string +} + +// InterfaceLookupByNameRet is libvirt's remote_interface_lookup_by_name_ret +type InterfaceLookupByNameRet struct { + Iface Interface +} + +// InterfaceLookupByMacStringArgs is libvirt's remote_interface_lookup_by_mac_string_args +type InterfaceLookupByMacStringArgs struct { + Mac string +} + +// InterfaceLookupByMacStringRet is libvirt's remote_interface_lookup_by_mac_string_ret +type InterfaceLookupByMacStringRet struct { + Iface Interface +} + +// InterfaceGetXMLDescArgs is libvirt's remote_interface_get_xml_desc_args +type InterfaceGetXMLDescArgs struct { + Iface Interface + Flags uint32 +} + +// InterfaceGetXMLDescRet is libvirt's remote_interface_get_xml_desc_ret +type InterfaceGetXMLDescRet struct { + XML string +} + +// InterfaceDefineXMLArgs is libvirt's remote_interface_define_xml_args +type InterfaceDefineXMLArgs struct { + XML string + Flags uint32 +} + +// InterfaceDefineXMLRet is libvirt's remote_interface_define_xml_ret +type InterfaceDefineXMLRet struct { + Iface Interface +} + +// InterfaceUndefineArgs is libvirt's remote_interface_undefine_args +type InterfaceUndefineArgs struct { + Iface Interface +} + +// InterfaceCreateArgs is libvirt's remote_interface_create_args +type InterfaceCreateArgs struct { + Iface Interface + Flags uint32 +} + +// InterfaceDestroyArgs is libvirt's remote_interface_destroy_args +type InterfaceDestroyArgs struct { + Iface Interface + Flags uint32 +} + +// InterfaceChangeBeginArgs is libvirt's remote_interface_change_begin_args +type InterfaceChangeBeginArgs struct { + Flags uint32 +} + +// InterfaceChangeCommitArgs is libvirt's remote_interface_change_commit_args +type InterfaceChangeCommitArgs struct { + Flags uint32 +} + +// InterfaceChangeRollbackArgs is libvirt's remote_interface_change_rollback_args +type InterfaceChangeRollbackArgs struct { + Flags uint32 +} + +// AuthListRet is libvirt's remote_auth_list_ret +type AuthListRet struct { + Types []AuthType +} + +// AuthSaslInitRet is libvirt's remote_auth_sasl_init_ret +type AuthSaslInitRet struct { + Mechlist string +} + +// AuthSaslStartArgs is libvirt's remote_auth_sasl_start_args +type AuthSaslStartArgs struct { + Mech string + Nil int32 + Data []int8 +} + +// AuthSaslStartRet is libvirt's remote_auth_sasl_start_ret +type AuthSaslStartRet struct { + Complete int32 + Nil int32 + Data []int8 +} + +// AuthSaslStepArgs is libvirt's remote_auth_sasl_step_args +type AuthSaslStepArgs struct { + Nil int32 + Data []int8 +} + +// AuthSaslStepRet is libvirt's remote_auth_sasl_step_ret +type AuthSaslStepRet struct { + Complete int32 + Nil int32 + Data []int8 +} + +// AuthPolkitRet is libvirt's remote_auth_polkit_ret +type AuthPolkitRet struct { + Complete int32 +} + +// ConnectNumOfStoragePoolsRet is libvirt's remote_connect_num_of_storage_pools_ret +type ConnectNumOfStoragePoolsRet struct { + Num int32 +} + +// ConnectListStoragePoolsArgs is libvirt's remote_connect_list_storage_pools_args +type ConnectListStoragePoolsArgs struct { + Maxnames int32 +} + +// ConnectListStoragePoolsRet is libvirt's remote_connect_list_storage_pools_ret +type ConnectListStoragePoolsRet struct { + Names []string +} + +// ConnectNumOfDefinedStoragePoolsRet is libvirt's remote_connect_num_of_defined_storage_pools_ret +type ConnectNumOfDefinedStoragePoolsRet struct { + Num int32 +} + +// ConnectListDefinedStoragePoolsArgs is libvirt's remote_connect_list_defined_storage_pools_args +type ConnectListDefinedStoragePoolsArgs struct { + Maxnames int32 +} + +// ConnectListDefinedStoragePoolsRet is libvirt's remote_connect_list_defined_storage_pools_ret +type ConnectListDefinedStoragePoolsRet struct { + Names []string +} + +// ConnectFindStoragePoolSourcesArgs is libvirt's remote_connect_find_storage_pool_sources_args +type ConnectFindStoragePoolSourcesArgs struct { + Type string + SrcSpec OptString + Flags uint32 +} + +// ConnectFindStoragePoolSourcesRet is libvirt's remote_connect_find_storage_pool_sources_ret +type ConnectFindStoragePoolSourcesRet struct { + XML string +} + +// StoragePoolLookupByUUIDArgs is libvirt's remote_storage_pool_lookup_by_uuid_args +type StoragePoolLookupByUUIDArgs struct { + UUID UUID +} + +// StoragePoolLookupByUUIDRet is libvirt's remote_storage_pool_lookup_by_uuid_ret +type StoragePoolLookupByUUIDRet struct { + Pool StoragePool +} + +// StoragePoolLookupByNameArgs is libvirt's remote_storage_pool_lookup_by_name_args +type StoragePoolLookupByNameArgs struct { + Name string +} + +// StoragePoolLookupByNameRet is libvirt's remote_storage_pool_lookup_by_name_ret +type StoragePoolLookupByNameRet struct { + Pool StoragePool +} + +// StoragePoolLookupByVolumeArgs is libvirt's remote_storage_pool_lookup_by_volume_args +type StoragePoolLookupByVolumeArgs struct { + Vol StorageVol +} + +// StoragePoolLookupByVolumeRet is libvirt's remote_storage_pool_lookup_by_volume_ret +type StoragePoolLookupByVolumeRet struct { + Pool StoragePool +} + +// StoragePoolLookupByTargetPathArgs is libvirt's remote_storage_pool_lookup_by_target_path_args +type StoragePoolLookupByTargetPathArgs struct { + Path string +} + +// StoragePoolLookupByTargetPathRet is libvirt's remote_storage_pool_lookup_by_target_path_ret +type StoragePoolLookupByTargetPathRet struct { + Pool StoragePool +} + +// StoragePoolCreateXMLArgs is libvirt's remote_storage_pool_create_xml_args +type StoragePoolCreateXMLArgs struct { + XML string + Flags StoragePoolCreateFlags +} + +// StoragePoolCreateXMLRet is libvirt's remote_storage_pool_create_xml_ret +type StoragePoolCreateXMLRet struct { + Pool StoragePool +} + +// StoragePoolDefineXMLArgs is libvirt's remote_storage_pool_define_xml_args +type StoragePoolDefineXMLArgs struct { + XML string + Flags uint32 +} + +// StoragePoolDefineXMLRet is libvirt's remote_storage_pool_define_xml_ret +type StoragePoolDefineXMLRet struct { + Pool StoragePool +} + +// StoragePoolBuildArgs is libvirt's remote_storage_pool_build_args +type StoragePoolBuildArgs struct { + Pool StoragePool + Flags StoragePoolBuildFlags +} + +// StoragePoolUndefineArgs is libvirt's remote_storage_pool_undefine_args +type StoragePoolUndefineArgs struct { + Pool StoragePool +} + +// StoragePoolCreateArgs is libvirt's remote_storage_pool_create_args +type StoragePoolCreateArgs struct { + Pool StoragePool + Flags StoragePoolCreateFlags +} + +// StoragePoolDestroyArgs is libvirt's remote_storage_pool_destroy_args +type StoragePoolDestroyArgs struct { + Pool StoragePool +} + +// StoragePoolDeleteArgs is libvirt's remote_storage_pool_delete_args +type StoragePoolDeleteArgs struct { + Pool StoragePool + Flags StoragePoolDeleteFlags +} + +// StoragePoolRefreshArgs is libvirt's remote_storage_pool_refresh_args +type StoragePoolRefreshArgs struct { + Pool StoragePool + Flags uint32 +} + +// StoragePoolGetXMLDescArgs is libvirt's remote_storage_pool_get_xml_desc_args +type StoragePoolGetXMLDescArgs struct { + Pool StoragePool + Flags StorageXMLFlags +} + +// StoragePoolGetXMLDescRet is libvirt's remote_storage_pool_get_xml_desc_ret +type StoragePoolGetXMLDescRet struct { + XML string +} + +// StoragePoolGetInfoArgs is libvirt's remote_storage_pool_get_info_args +type StoragePoolGetInfoArgs struct { + Pool StoragePool +} + +// StoragePoolGetInfoRet is libvirt's remote_storage_pool_get_info_ret +type StoragePoolGetInfoRet struct { + State uint8 + Capacity uint64 + Allocation uint64 + Available uint64 +} + +// StoragePoolGetAutostartArgs is libvirt's remote_storage_pool_get_autostart_args +type StoragePoolGetAutostartArgs struct { + Pool StoragePool +} + +// StoragePoolGetAutostartRet is libvirt's remote_storage_pool_get_autostart_ret +type StoragePoolGetAutostartRet struct { + Autostart int32 +} + +// StoragePoolSetAutostartArgs is libvirt's remote_storage_pool_set_autostart_args +type StoragePoolSetAutostartArgs struct { + Pool StoragePool + Autostart int32 +} + +// StoragePoolNumOfVolumesArgs is libvirt's remote_storage_pool_num_of_volumes_args +type StoragePoolNumOfVolumesArgs struct { + Pool StoragePool +} + +// StoragePoolNumOfVolumesRet is libvirt's remote_storage_pool_num_of_volumes_ret +type StoragePoolNumOfVolumesRet struct { + Num int32 +} + +// StoragePoolListVolumesArgs is libvirt's remote_storage_pool_list_volumes_args +type StoragePoolListVolumesArgs struct { + Pool StoragePool + Maxnames int32 +} + +// StoragePoolListVolumesRet is libvirt's remote_storage_pool_list_volumes_ret +type StoragePoolListVolumesRet struct { + Names []string +} + +// StorageVolLookupByNameArgs is libvirt's remote_storage_vol_lookup_by_name_args +type StorageVolLookupByNameArgs struct { + Pool StoragePool + Name string +} + +// StorageVolLookupByNameRet is libvirt's remote_storage_vol_lookup_by_name_ret +type StorageVolLookupByNameRet struct { + Vol StorageVol +} + +// StorageVolLookupByKeyArgs is libvirt's remote_storage_vol_lookup_by_key_args +type StorageVolLookupByKeyArgs struct { + Key string +} + +// StorageVolLookupByKeyRet is libvirt's remote_storage_vol_lookup_by_key_ret +type StorageVolLookupByKeyRet struct { + Vol StorageVol +} + +// StorageVolLookupByPathArgs is libvirt's remote_storage_vol_lookup_by_path_args +type StorageVolLookupByPathArgs struct { + Path string +} + +// StorageVolLookupByPathRet is libvirt's remote_storage_vol_lookup_by_path_ret +type StorageVolLookupByPathRet struct { + Vol StorageVol +} + +// StorageVolCreateXMLArgs is libvirt's remote_storage_vol_create_xml_args +type StorageVolCreateXMLArgs struct { + Pool StoragePool + XML string + Flags StorageVolCreateFlags +} + +// StorageVolCreateXMLRet is libvirt's remote_storage_vol_create_xml_ret +type StorageVolCreateXMLRet struct { + Vol StorageVol +} + +// StorageVolCreateXMLFromArgs is libvirt's remote_storage_vol_create_xml_from_args +type StorageVolCreateXMLFromArgs struct { + Pool StoragePool + XML string + Clonevol StorageVol + Flags StorageVolCreateFlags +} + +// StorageVolCreateXMLFromRet is libvirt's remote_storage_vol_create_xml_from_ret +type StorageVolCreateXMLFromRet struct { + Vol StorageVol +} + +// StorageVolDeleteArgs is libvirt's remote_storage_vol_delete_args +type StorageVolDeleteArgs struct { + Vol StorageVol + Flags StorageVolDeleteFlags +} + +// StorageVolWipeArgs is libvirt's remote_storage_vol_wipe_args +type StorageVolWipeArgs struct { + Vol StorageVol + Flags uint32 +} + +// StorageVolWipePatternArgs is libvirt's remote_storage_vol_wipe_pattern_args +type StorageVolWipePatternArgs struct { + Vol StorageVol + Algorithm uint32 + Flags uint32 +} + +// StorageVolGetXMLDescArgs is libvirt's remote_storage_vol_get_xml_desc_args +type StorageVolGetXMLDescArgs struct { + Vol StorageVol + Flags uint32 +} + +// StorageVolGetXMLDescRet is libvirt's remote_storage_vol_get_xml_desc_ret +type StorageVolGetXMLDescRet struct { + XML string +} + +// StorageVolGetInfoArgs is libvirt's remote_storage_vol_get_info_args +type StorageVolGetInfoArgs struct { + Vol StorageVol +} + +// StorageVolGetInfoRet is libvirt's remote_storage_vol_get_info_ret +type StorageVolGetInfoRet struct { + Type int8 + Capacity uint64 + Allocation uint64 +} + +// StorageVolGetInfoFlagsArgs is libvirt's remote_storage_vol_get_info_flags_args +type StorageVolGetInfoFlagsArgs struct { + Vol StorageVol + Flags uint32 +} + +// StorageVolGetInfoFlagsRet is libvirt's remote_storage_vol_get_info_flags_ret +type StorageVolGetInfoFlagsRet struct { + Type int8 + Capacity uint64 + Allocation uint64 +} + +// StorageVolGetPathArgs is libvirt's remote_storage_vol_get_path_args +type StorageVolGetPathArgs struct { + Vol StorageVol +} + +// StorageVolGetPathRet is libvirt's remote_storage_vol_get_path_ret +type StorageVolGetPathRet struct { + Name string +} + +// StorageVolResizeArgs is libvirt's remote_storage_vol_resize_args +type StorageVolResizeArgs struct { + Vol StorageVol + Capacity uint64 + Flags StorageVolResizeFlags +} + +// NodeNumOfDevicesArgs is libvirt's remote_node_num_of_devices_args +type NodeNumOfDevicesArgs struct { + Cap OptString + Flags uint32 +} + +// NodeNumOfDevicesRet is libvirt's remote_node_num_of_devices_ret +type NodeNumOfDevicesRet struct { + Num int32 +} + +// NodeListDevicesArgs is libvirt's remote_node_list_devices_args +type NodeListDevicesArgs struct { + Cap OptString + Maxnames int32 + Flags uint32 +} + +// NodeListDevicesRet is libvirt's remote_node_list_devices_ret +type NodeListDevicesRet struct { + Names []string +} + +// NodeDeviceLookupByNameArgs is libvirt's remote_node_device_lookup_by_name_args +type NodeDeviceLookupByNameArgs struct { + Name string +} + +// NodeDeviceLookupByNameRet is libvirt's remote_node_device_lookup_by_name_ret +type NodeDeviceLookupByNameRet struct { + Dev NodeDevice +} + +// NodeDeviceLookupScsiHostByWwnArgs is libvirt's remote_node_device_lookup_scsi_host_by_wwn_args +type NodeDeviceLookupScsiHostByWwnArgs struct { + Wwnn string + Wwpn string + Flags uint32 +} + +// NodeDeviceLookupScsiHostByWwnRet is libvirt's remote_node_device_lookup_scsi_host_by_wwn_ret +type NodeDeviceLookupScsiHostByWwnRet struct { + Dev NodeDevice +} + +// NodeDeviceGetXMLDescArgs is libvirt's remote_node_device_get_xml_desc_args +type NodeDeviceGetXMLDescArgs struct { + Name string + Flags uint32 +} + +// NodeDeviceGetXMLDescRet is libvirt's remote_node_device_get_xml_desc_ret +type NodeDeviceGetXMLDescRet struct { + XML string +} + +// NodeDeviceGetParentArgs is libvirt's remote_node_device_get_parent_args +type NodeDeviceGetParentArgs struct { + Name string +} + +// NodeDeviceGetParentRet is libvirt's remote_node_device_get_parent_ret +type NodeDeviceGetParentRet struct { + ParentName OptString +} + +// NodeDeviceNumOfCapsArgs is libvirt's remote_node_device_num_of_caps_args +type NodeDeviceNumOfCapsArgs struct { + Name string +} + +// NodeDeviceNumOfCapsRet is libvirt's remote_node_device_num_of_caps_ret +type NodeDeviceNumOfCapsRet struct { + Num int32 +} + +// NodeDeviceListCapsArgs is libvirt's remote_node_device_list_caps_args +type NodeDeviceListCapsArgs struct { + Name string + Maxnames int32 +} + +// NodeDeviceListCapsRet is libvirt's remote_node_device_list_caps_ret +type NodeDeviceListCapsRet struct { + Names []string +} + +// NodeDeviceDettachArgs is libvirt's remote_node_device_dettach_args +type NodeDeviceDettachArgs struct { + Name string +} + +// NodeDeviceDetachFlagsArgs is libvirt's remote_node_device_detach_flags_args +type NodeDeviceDetachFlagsArgs struct { + Name string + DriverName OptString + Flags uint32 +} + +// NodeDeviceReAttachArgs is libvirt's remote_node_device_re_attach_args +type NodeDeviceReAttachArgs struct { + Name string +} + +// NodeDeviceResetArgs is libvirt's remote_node_device_reset_args +type NodeDeviceResetArgs struct { + Name string +} + +// NodeDeviceCreateXMLArgs is libvirt's remote_node_device_create_xml_args +type NodeDeviceCreateXMLArgs struct { + XMLDesc string + Flags uint32 +} + +// NodeDeviceCreateXMLRet is libvirt's remote_node_device_create_xml_ret +type NodeDeviceCreateXMLRet struct { + Dev NodeDevice +} + +// NodeDeviceDestroyArgs is libvirt's remote_node_device_destroy_args +type NodeDeviceDestroyArgs struct { + Name string +} + +// ConnectDomainEventRegisterRet is libvirt's remote_connect_domain_event_register_ret +type ConnectDomainEventRegisterRet struct { + CbRegistered int32 +} + +// ConnectDomainEventDeregisterRet is libvirt's remote_connect_domain_event_deregister_ret +type ConnectDomainEventDeregisterRet struct { + CbRegistered int32 +} + +// DomainEventLifecycleMsg is libvirt's remote_domain_event_lifecycle_msg +type DomainEventLifecycleMsg struct { + Dom Domain + Event int32 + Detail int32 +} + +// DomainEventCallbackLifecycleMsg is libvirt's remote_domain_event_callback_lifecycle_msg +type DomainEventCallbackLifecycleMsg struct { + CallbackID int32 + Msg DomainEventLifecycleMsg +} + +// ConnectDomainXMLFromNativeArgs is libvirt's remote_connect_domain_xml_from_native_args +type ConnectDomainXMLFromNativeArgs struct { + NativeFormat string + NativeConfig string + Flags uint32 +} + +// ConnectDomainXMLFromNativeRet is libvirt's remote_connect_domain_xml_from_native_ret +type ConnectDomainXMLFromNativeRet struct { + DomainXML string +} + +// ConnectDomainXMLToNativeArgs is libvirt's remote_connect_domain_xml_to_native_args +type ConnectDomainXMLToNativeArgs struct { + NativeFormat string + DomainXML string + Flags uint32 +} + +// ConnectDomainXMLToNativeRet is libvirt's remote_connect_domain_xml_to_native_ret +type ConnectDomainXMLToNativeRet struct { + NativeConfig string +} + +// ConnectNumOfSecretsRet is libvirt's remote_connect_num_of_secrets_ret +type ConnectNumOfSecretsRet struct { + Num int32 +} + +// ConnectListSecretsArgs is libvirt's remote_connect_list_secrets_args +type ConnectListSecretsArgs struct { + Maxuuids int32 +} + +// ConnectListSecretsRet is libvirt's remote_connect_list_secrets_ret +type ConnectListSecretsRet struct { + Uuids []string +} + +// SecretLookupByUUIDArgs is libvirt's remote_secret_lookup_by_uuid_args +type SecretLookupByUUIDArgs struct { + UUID UUID +} + +// SecretLookupByUUIDRet is libvirt's remote_secret_lookup_by_uuid_ret +type SecretLookupByUUIDRet struct { + OptSecret Secret +} + +// SecretDefineXMLArgs is libvirt's remote_secret_define_xml_args +type SecretDefineXMLArgs struct { + XML string + Flags uint32 +} + +// SecretDefineXMLRet is libvirt's remote_secret_define_xml_ret +type SecretDefineXMLRet struct { + OptSecret Secret +} + +// SecretGetXMLDescArgs is libvirt's remote_secret_get_xml_desc_args +type SecretGetXMLDescArgs struct { + OptSecret Secret + Flags uint32 +} + +// SecretGetXMLDescRet is libvirt's remote_secret_get_xml_desc_ret +type SecretGetXMLDescRet struct { + XML string +} + +// SecretSetValueArgs is libvirt's remote_secret_set_value_args +type SecretSetValueArgs struct { + OptSecret Secret + Value []byte + Flags uint32 +} + +// SecretGetValueArgs is libvirt's remote_secret_get_value_args +type SecretGetValueArgs struct { + OptSecret Secret + Flags uint32 +} + +// SecretGetValueRet is libvirt's remote_secret_get_value_ret +type SecretGetValueRet struct { + Value []byte +} + +// SecretUndefineArgs is libvirt's remote_secret_undefine_args +type SecretUndefineArgs struct { + OptSecret Secret +} + +// SecretLookupByUsageArgs is libvirt's remote_secret_lookup_by_usage_args +type SecretLookupByUsageArgs struct { + UsageType int32 + UsageID string +} + +// SecretLookupByUsageRet is libvirt's remote_secret_lookup_by_usage_ret +type SecretLookupByUsageRet struct { + OptSecret Secret +} + +// DomainMigratePrepareTunnelArgs is libvirt's remote_domain_migrate_prepare_tunnel_args +type DomainMigratePrepareTunnelArgs struct { + Flags uint64 + Dname OptString + Resource uint64 + DomXML string +} + +// ConnectIsSecureRet is libvirt's remote_connect_is_secure_ret +type ConnectIsSecureRet struct { + Secure int32 +} + +// DomainIsActiveArgs is libvirt's remote_domain_is_active_args +type DomainIsActiveArgs struct { + Dom Domain +} + +// DomainIsActiveRet is libvirt's remote_domain_is_active_ret +type DomainIsActiveRet struct { + Active int32 +} + +// DomainIsPersistentArgs is libvirt's remote_domain_is_persistent_args +type DomainIsPersistentArgs struct { + Dom Domain +} + +// DomainIsPersistentRet is libvirt's remote_domain_is_persistent_ret +type DomainIsPersistentRet struct { + Persistent int32 +} + +// DomainIsUpdatedArgs is libvirt's remote_domain_is_updated_args +type DomainIsUpdatedArgs struct { + Dom Domain +} + +// DomainIsUpdatedRet is libvirt's remote_domain_is_updated_ret +type DomainIsUpdatedRet struct { + Updated int32 +} + +// NetworkIsActiveArgs is libvirt's remote_network_is_active_args +type NetworkIsActiveArgs struct { + Net Network +} + +// NetworkIsActiveRet is libvirt's remote_network_is_active_ret +type NetworkIsActiveRet struct { + Active int32 +} + +// NetworkIsPersistentArgs is libvirt's remote_network_is_persistent_args +type NetworkIsPersistentArgs struct { + Net Network +} + +// NetworkIsPersistentRet is libvirt's remote_network_is_persistent_ret +type NetworkIsPersistentRet struct { + Persistent int32 +} + +// StoragePoolIsActiveArgs is libvirt's remote_storage_pool_is_active_args +type StoragePoolIsActiveArgs struct { + Pool StoragePool +} + +// StoragePoolIsActiveRet is libvirt's remote_storage_pool_is_active_ret +type StoragePoolIsActiveRet struct { + Active int32 +} + +// StoragePoolIsPersistentArgs is libvirt's remote_storage_pool_is_persistent_args +type StoragePoolIsPersistentArgs struct { + Pool StoragePool +} + +// StoragePoolIsPersistentRet is libvirt's remote_storage_pool_is_persistent_ret +type StoragePoolIsPersistentRet struct { + Persistent int32 +} + +// InterfaceIsActiveArgs is libvirt's remote_interface_is_active_args +type InterfaceIsActiveArgs struct { + Iface Interface +} + +// InterfaceIsActiveRet is libvirt's remote_interface_is_active_ret +type InterfaceIsActiveRet struct { + Active int32 +} + +// ConnectCompareCPUArgs is libvirt's remote_connect_compare_cpu_args +type ConnectCompareCPUArgs struct { + XML string + Flags ConnectCompareCPUFlags +} + +// ConnectCompareCPURet is libvirt's remote_connect_compare_cpu_ret +type ConnectCompareCPURet struct { + Result int32 +} + +// ConnectBaselineCPUArgs is libvirt's remote_connect_baseline_cpu_args +type ConnectBaselineCPUArgs struct { + XMLCPUs []string + Flags ConnectBaselineCPUFlags +} + +// ConnectBaselineCPURet is libvirt's remote_connect_baseline_cpu_ret +type ConnectBaselineCPURet struct { + CPU string +} + +// DomainGetJobInfoArgs is libvirt's remote_domain_get_job_info_args +type DomainGetJobInfoArgs struct { + Dom Domain +} + +// DomainGetJobInfoRet is libvirt's remote_domain_get_job_info_ret +type DomainGetJobInfoRet struct { + Type int32 + TimeElapsed uint64 + TimeRemaining uint64 + DataTotal uint64 + DataProcessed uint64 + DataRemaining uint64 + MemTotal uint64 + MemProcessed uint64 + MemRemaining uint64 + FileTotal uint64 + FileProcessed uint64 + FileRemaining uint64 +} + +// DomainGetJobStatsArgs is libvirt's remote_domain_get_job_stats_args +type DomainGetJobStatsArgs struct { + Dom Domain + Flags DomainGetJobStatsFlags +} + +// DomainGetJobStatsRet is libvirt's remote_domain_get_job_stats_ret +type DomainGetJobStatsRet struct { + Type int32 + Params []TypedParam +} + +// DomainAbortJobArgs is libvirt's remote_domain_abort_job_args +type DomainAbortJobArgs struct { + Dom Domain +} + +// DomainMigrateGetMaxDowntimeArgs is libvirt's remote_domain_migrate_get_max_downtime_args +type DomainMigrateGetMaxDowntimeArgs struct { + Dom Domain + Flags uint32 +} + +// DomainMigrateGetMaxDowntimeRet is libvirt's remote_domain_migrate_get_max_downtime_ret +type DomainMigrateGetMaxDowntimeRet struct { + Downtime uint64 +} + +// DomainMigrateSetMaxDowntimeArgs is libvirt's remote_domain_migrate_set_max_downtime_args +type DomainMigrateSetMaxDowntimeArgs struct { + Dom Domain + Downtime uint64 + Flags uint32 +} + +// DomainMigrateGetCompressionCacheArgs is libvirt's remote_domain_migrate_get_compression_cache_args +type DomainMigrateGetCompressionCacheArgs struct { + Dom Domain + Flags uint32 +} + +// DomainMigrateGetCompressionCacheRet is libvirt's remote_domain_migrate_get_compression_cache_ret +type DomainMigrateGetCompressionCacheRet struct { + CacheSize uint64 +} + +// DomainMigrateSetCompressionCacheArgs is libvirt's remote_domain_migrate_set_compression_cache_args +type DomainMigrateSetCompressionCacheArgs struct { + Dom Domain + CacheSize uint64 + Flags uint32 +} + +// DomainMigrateSetMaxSpeedArgs is libvirt's remote_domain_migrate_set_max_speed_args +type DomainMigrateSetMaxSpeedArgs struct { + Dom Domain + Bandwidth uint64 + Flags uint32 +} + +// DomainMigrateGetMaxSpeedArgs is libvirt's remote_domain_migrate_get_max_speed_args +type DomainMigrateGetMaxSpeedArgs struct { + Dom Domain + Flags uint32 +} + +// DomainMigrateGetMaxSpeedRet is libvirt's remote_domain_migrate_get_max_speed_ret +type DomainMigrateGetMaxSpeedRet struct { + Bandwidth uint64 +} + +// ConnectDomainEventRegisterAnyArgs is libvirt's remote_connect_domain_event_register_any_args +type ConnectDomainEventRegisterAnyArgs struct { + EventID int32 +} + +// ConnectDomainEventDeregisterAnyArgs is libvirt's remote_connect_domain_event_deregister_any_args +type ConnectDomainEventDeregisterAnyArgs struct { + EventID int32 +} + +// ConnectDomainEventCallbackRegisterAnyArgs is libvirt's remote_connect_domain_event_callback_register_any_args +type ConnectDomainEventCallbackRegisterAnyArgs struct { + EventID int32 + Dom OptDomain +} + +// ConnectDomainEventCallbackRegisterAnyRet is libvirt's remote_connect_domain_event_callback_register_any_ret +type ConnectDomainEventCallbackRegisterAnyRet struct { + CallbackID int32 +} + +// ConnectDomainEventCallbackDeregisterAnyArgs is libvirt's remote_connect_domain_event_callback_deregister_any_args +type ConnectDomainEventCallbackDeregisterAnyArgs struct { + CallbackID int32 +} + +// DomainEventRebootMsg is libvirt's remote_domain_event_reboot_msg +type DomainEventRebootMsg struct { + Dom Domain +} + +// DomainEventCallbackRebootMsg is libvirt's remote_domain_event_callback_reboot_msg +type DomainEventCallbackRebootMsg struct { + CallbackID int32 + Msg DomainEventRebootMsg +} + +// DomainEventRtcChangeMsg is libvirt's remote_domain_event_rtc_change_msg +type DomainEventRtcChangeMsg struct { + Dom Domain + Offset int64 +} + +// DomainEventCallbackRtcChangeMsg is libvirt's remote_domain_event_callback_rtc_change_msg +type DomainEventCallbackRtcChangeMsg struct { + CallbackID int32 + Msg DomainEventRtcChangeMsg +} + +// DomainEventWatchdogMsg is libvirt's remote_domain_event_watchdog_msg +type DomainEventWatchdogMsg struct { + Dom Domain + Action int32 +} + +// DomainEventCallbackWatchdogMsg is libvirt's remote_domain_event_callback_watchdog_msg +type DomainEventCallbackWatchdogMsg struct { + CallbackID int32 + Msg DomainEventWatchdogMsg +} + +// DomainEventIOErrorMsg is libvirt's remote_domain_event_io_error_msg +type DomainEventIOErrorMsg struct { + Dom Domain + SrcPath string + DevAlias string + Action int32 +} + +// DomainEventCallbackIOErrorMsg is libvirt's remote_domain_event_callback_io_error_msg +type DomainEventCallbackIOErrorMsg struct { + CallbackID int32 + Msg DomainEventIOErrorMsg +} + +// DomainEventIOErrorReasonMsg is libvirt's remote_domain_event_io_error_reason_msg +type DomainEventIOErrorReasonMsg struct { + Dom Domain + SrcPath string + DevAlias string + Action int32 + Reason string +} + +// DomainEventCallbackIOErrorReasonMsg is libvirt's remote_domain_event_callback_io_error_reason_msg +type DomainEventCallbackIOErrorReasonMsg struct { + CallbackID int32 + Msg DomainEventIOErrorReasonMsg +} + +// DomainEventGraphicsAddress is libvirt's remote_domain_event_graphics_address +type DomainEventGraphicsAddress struct { + Family int32 + Node string + Service string +} + +// DomainEventGraphicsIdentity is libvirt's remote_domain_event_graphics_identity +type DomainEventGraphicsIdentity struct { + Type string + Name string +} + +// DomainEventGraphicsMsg is libvirt's remote_domain_event_graphics_msg +type DomainEventGraphicsMsg struct { + Dom Domain + Phase int32 + Local DomainEventGraphicsAddress + Remote DomainEventGraphicsAddress + AuthScheme string + Subject []DomainEventGraphicsIdentity +} + +// DomainEventCallbackGraphicsMsg is libvirt's remote_domain_event_callback_graphics_msg +type DomainEventCallbackGraphicsMsg struct { + CallbackID int32 + Msg DomainEventGraphicsMsg +} + +// DomainEventBlockJobMsg is libvirt's remote_domain_event_block_job_msg +type DomainEventBlockJobMsg struct { + Dom Domain + Path string + Type int32 + Status int32 +} + +// DomainEventCallbackBlockJobMsg is libvirt's remote_domain_event_callback_block_job_msg +type DomainEventCallbackBlockJobMsg struct { + CallbackID int32 + Msg DomainEventBlockJobMsg +} + +// DomainEventDiskChangeMsg is libvirt's remote_domain_event_disk_change_msg +type DomainEventDiskChangeMsg struct { + Dom Domain + OldSrcPath OptString + NewSrcPath OptString + DevAlias string + Reason int32 +} + +// DomainEventCallbackDiskChangeMsg is libvirt's remote_domain_event_callback_disk_change_msg +type DomainEventCallbackDiskChangeMsg struct { + CallbackID int32 + Msg DomainEventDiskChangeMsg +} + +// DomainEventTrayChangeMsg is libvirt's remote_domain_event_tray_change_msg +type DomainEventTrayChangeMsg struct { + Dom Domain + DevAlias string + Reason int32 +} + +// DomainEventCallbackTrayChangeMsg is libvirt's remote_domain_event_callback_tray_change_msg +type DomainEventCallbackTrayChangeMsg struct { + CallbackID int32 + Msg DomainEventTrayChangeMsg +} + +// DomainEventPmwakeupMsg is libvirt's remote_domain_event_pmwakeup_msg +type DomainEventPmwakeupMsg struct { + Dom Domain +} + +// DomainEventCallbackPmwakeupMsg is libvirt's remote_domain_event_callback_pmwakeup_msg +type DomainEventCallbackPmwakeupMsg struct { + CallbackID int32 + Reason int32 + Msg DomainEventPmwakeupMsg +} + +// DomainEventPmsuspendMsg is libvirt's remote_domain_event_pmsuspend_msg +type DomainEventPmsuspendMsg struct { + Dom Domain +} + +// DomainEventCallbackPmsuspendMsg is libvirt's remote_domain_event_callback_pmsuspend_msg +type DomainEventCallbackPmsuspendMsg struct { + CallbackID int32 + Reason int32 + Msg DomainEventPmsuspendMsg +} + +// DomainEventBalloonChangeMsg is libvirt's remote_domain_event_balloon_change_msg +type DomainEventBalloonChangeMsg struct { + Dom Domain + Actual uint64 +} + +// DomainEventCallbackBalloonChangeMsg is libvirt's remote_domain_event_callback_balloon_change_msg +type DomainEventCallbackBalloonChangeMsg struct { + CallbackID int32 + Msg DomainEventBalloonChangeMsg +} + +// DomainEventPmsuspendDiskMsg is libvirt's remote_domain_event_pmsuspend_disk_msg +type DomainEventPmsuspendDiskMsg struct { + Dom Domain +} + +// DomainEventCallbackPmsuspendDiskMsg is libvirt's remote_domain_event_callback_pmsuspend_disk_msg +type DomainEventCallbackPmsuspendDiskMsg struct { + CallbackID int32 + Reason int32 + Msg DomainEventPmsuspendDiskMsg +} + +// DomainManagedSaveArgs is libvirt's remote_domain_managed_save_args +type DomainManagedSaveArgs struct { + Dom Domain + Flags uint32 +} + +// DomainHasManagedSaveImageArgs is libvirt's remote_domain_has_managed_save_image_args +type DomainHasManagedSaveImageArgs struct { + Dom Domain + Flags uint32 +} + +// DomainHasManagedSaveImageRet is libvirt's remote_domain_has_managed_save_image_ret +type DomainHasManagedSaveImageRet struct { + Result int32 +} + +// DomainManagedSaveRemoveArgs is libvirt's remote_domain_managed_save_remove_args +type DomainManagedSaveRemoveArgs struct { + Dom Domain + Flags uint32 +} + +// DomainManagedSaveGetXMLDescArgs is libvirt's remote_domain_managed_save_get_xml_desc_args +type DomainManagedSaveGetXMLDescArgs struct { + Dom Domain + Flags DomainXMLFlags +} + +// DomainManagedSaveGetXMLDescRet is libvirt's remote_domain_managed_save_get_xml_desc_ret +type DomainManagedSaveGetXMLDescRet struct { + XML string +} + +// DomainManagedSaveDefineXMLArgs is libvirt's remote_domain_managed_save_define_xml_args +type DomainManagedSaveDefineXMLArgs struct { + Dom Domain + Dxml OptString + Flags DomainSaveRestoreFlags +} + +// DomainSnapshotCreateXMLArgs is libvirt's remote_domain_snapshot_create_xml_args +type DomainSnapshotCreateXMLArgs struct { + Dom Domain + XMLDesc string + Flags uint32 +} + +// DomainSnapshotCreateXMLRet is libvirt's remote_domain_snapshot_create_xml_ret +type DomainSnapshotCreateXMLRet struct { + Snap DomainSnapshot +} + +// DomainSnapshotGetXMLDescArgs is libvirt's remote_domain_snapshot_get_xml_desc_args +type DomainSnapshotGetXMLDescArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotGetXMLDescRet is libvirt's remote_domain_snapshot_get_xml_desc_ret +type DomainSnapshotGetXMLDescRet struct { + XML string +} + +// DomainSnapshotNumArgs is libvirt's remote_domain_snapshot_num_args +type DomainSnapshotNumArgs struct { + Dom Domain + Flags uint32 +} + +// DomainSnapshotNumRet is libvirt's remote_domain_snapshot_num_ret +type DomainSnapshotNumRet struct { + Num int32 +} + +// DomainSnapshotListNamesArgs is libvirt's remote_domain_snapshot_list_names_args +type DomainSnapshotListNamesArgs struct { + Dom Domain + Maxnames int32 + Flags uint32 +} + +// DomainSnapshotListNamesRet is libvirt's remote_domain_snapshot_list_names_ret +type DomainSnapshotListNamesRet struct { + Names []string +} + +// DomainListAllSnapshotsArgs is libvirt's remote_domain_list_all_snapshots_args +type DomainListAllSnapshotsArgs struct { + Dom Domain + NeedResults int32 + Flags uint32 +} + +// DomainListAllSnapshotsRet is libvirt's remote_domain_list_all_snapshots_ret +type DomainListAllSnapshotsRet struct { + Snapshots []DomainSnapshot + Ret int32 +} + +// DomainSnapshotNumChildrenArgs is libvirt's remote_domain_snapshot_num_children_args +type DomainSnapshotNumChildrenArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotNumChildrenRet is libvirt's remote_domain_snapshot_num_children_ret +type DomainSnapshotNumChildrenRet struct { + Num int32 +} + +// DomainSnapshotListChildrenNamesArgs is libvirt's remote_domain_snapshot_list_children_names_args +type DomainSnapshotListChildrenNamesArgs struct { + Snap DomainSnapshot + Maxnames int32 + Flags uint32 +} + +// DomainSnapshotListChildrenNamesRet is libvirt's remote_domain_snapshot_list_children_names_ret +type DomainSnapshotListChildrenNamesRet struct { + Names []string +} + +// DomainSnapshotListAllChildrenArgs is libvirt's remote_domain_snapshot_list_all_children_args +type DomainSnapshotListAllChildrenArgs struct { + Snapshot DomainSnapshot + NeedResults int32 + Flags uint32 +} + +// DomainSnapshotListAllChildrenRet is libvirt's remote_domain_snapshot_list_all_children_ret +type DomainSnapshotListAllChildrenRet struct { + Snapshots []DomainSnapshot + Ret int32 +} + +// DomainSnapshotLookupByNameArgs is libvirt's remote_domain_snapshot_lookup_by_name_args +type DomainSnapshotLookupByNameArgs struct { + Dom Domain + Name string + Flags uint32 +} + +// DomainSnapshotLookupByNameRet is libvirt's remote_domain_snapshot_lookup_by_name_ret +type DomainSnapshotLookupByNameRet struct { + Snap DomainSnapshot +} + +// DomainHasCurrentSnapshotArgs is libvirt's remote_domain_has_current_snapshot_args +type DomainHasCurrentSnapshotArgs struct { + Dom Domain + Flags uint32 +} + +// DomainHasCurrentSnapshotRet is libvirt's remote_domain_has_current_snapshot_ret +type DomainHasCurrentSnapshotRet struct { + Result int32 +} + +// DomainSnapshotGetParentArgs is libvirt's remote_domain_snapshot_get_parent_args +type DomainSnapshotGetParentArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotGetParentRet is libvirt's remote_domain_snapshot_get_parent_ret +type DomainSnapshotGetParentRet struct { + Snap DomainSnapshot +} + +// DomainSnapshotCurrentArgs is libvirt's remote_domain_snapshot_current_args +type DomainSnapshotCurrentArgs struct { + Dom Domain + Flags uint32 +} + +// DomainSnapshotCurrentRet is libvirt's remote_domain_snapshot_current_ret +type DomainSnapshotCurrentRet struct { + Snap DomainSnapshot +} + +// DomainSnapshotIsCurrentArgs is libvirt's remote_domain_snapshot_is_current_args +type DomainSnapshotIsCurrentArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotIsCurrentRet is libvirt's remote_domain_snapshot_is_current_ret +type DomainSnapshotIsCurrentRet struct { + Current int32 +} + +// DomainSnapshotHasMetadataArgs is libvirt's remote_domain_snapshot_has_metadata_args +type DomainSnapshotHasMetadataArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotHasMetadataRet is libvirt's remote_domain_snapshot_has_metadata_ret +type DomainSnapshotHasMetadataRet struct { + Metadata int32 +} + +// DomainRevertToSnapshotArgs is libvirt's remote_domain_revert_to_snapshot_args +type DomainRevertToSnapshotArgs struct { + Snap DomainSnapshot + Flags uint32 +} + +// DomainSnapshotDeleteArgs is libvirt's remote_domain_snapshot_delete_args +type DomainSnapshotDeleteArgs struct { + Snap DomainSnapshot + Flags DomainSnapshotDeleteFlags +} + +// DomainOpenConsoleArgs is libvirt's remote_domain_open_console_args +type DomainOpenConsoleArgs struct { + Dom Domain + DevName OptString + Flags uint32 +} + +// DomainOpenChannelArgs is libvirt's remote_domain_open_channel_args +type DomainOpenChannelArgs struct { + Dom Domain + Name OptString + Flags DomainChannelFlags +} + +// StorageVolUploadArgs is libvirt's remote_storage_vol_upload_args +type StorageVolUploadArgs struct { + Vol StorageVol + Offset uint64 + Length uint64 + Flags StorageVolUploadFlags +} + +// StorageVolDownloadArgs is libvirt's remote_storage_vol_download_args +type StorageVolDownloadArgs struct { + Vol StorageVol + Offset uint64 + Length uint64 + Flags StorageVolDownloadFlags +} + +// DomainGetStateArgs is libvirt's remote_domain_get_state_args +type DomainGetStateArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetStateRet is libvirt's remote_domain_get_state_ret +type DomainGetStateRet struct { + State int32 + Reason int32 +} + +// DomainMigrateBegin3Args is libvirt's remote_domain_migrate_begin3_args +type DomainMigrateBegin3Args struct { + Dom Domain + Xmlin OptString + Flags uint64 + Dname OptString + Resource uint64 +} + +// DomainMigrateBegin3Ret is libvirt's remote_domain_migrate_begin3_ret +type DomainMigrateBegin3Ret struct { + CookieOut []byte + XML string +} + +// DomainMigratePrepare3Args is libvirt's remote_domain_migrate_prepare3_args +type DomainMigratePrepare3Args struct { + CookieIn []byte + UriIn OptString + Flags uint64 + Dname OptString + Resource uint64 + DomXML string +} + +// DomainMigratePrepare3Ret is libvirt's remote_domain_migrate_prepare3_ret +type DomainMigratePrepare3Ret struct { + CookieOut []byte + UriOut OptString +} + +// DomainMigratePrepareTunnel3Args is libvirt's remote_domain_migrate_prepare_tunnel3_args +type DomainMigratePrepareTunnel3Args struct { + CookieIn []byte + Flags uint64 + Dname OptString + Resource uint64 + DomXML string +} + +// DomainMigratePrepareTunnel3Ret is libvirt's remote_domain_migrate_prepare_tunnel3_ret +type DomainMigratePrepareTunnel3Ret struct { + CookieOut []byte +} + +// DomainMigratePerform3Args is libvirt's remote_domain_migrate_perform3_args +type DomainMigratePerform3Args struct { + Dom Domain + Xmlin OptString + CookieIn []byte + Dconnuri OptString + Uri OptString + Flags uint64 + Dname OptString + Resource uint64 +} + +// DomainMigratePerform3Ret is libvirt's remote_domain_migrate_perform3_ret +type DomainMigratePerform3Ret struct { + CookieOut []byte +} + +// DomainMigrateFinish3Args is libvirt's remote_domain_migrate_finish3_args +type DomainMigrateFinish3Args struct { + Dname string + CookieIn []byte + Dconnuri OptString + Uri OptString + Flags uint64 + Cancelled int32 +} + +// DomainMigrateFinish3Ret is libvirt's remote_domain_migrate_finish3_ret +type DomainMigrateFinish3Ret struct { + Dom Domain + CookieOut []byte +} + +// DomainMigrateConfirm3Args is libvirt's remote_domain_migrate_confirm3_args +type DomainMigrateConfirm3Args struct { + Dom Domain + CookieIn []byte + Flags uint64 + Cancelled int32 +} + +// DomainEventControlErrorMsg is libvirt's remote_domain_event_control_error_msg +type DomainEventControlErrorMsg struct { + Dom Domain +} + +// DomainEventCallbackControlErrorMsg is libvirt's remote_domain_event_callback_control_error_msg +type DomainEventCallbackControlErrorMsg struct { + CallbackID int32 + Msg DomainEventControlErrorMsg +} + +// DomainGetControlInfoArgs is libvirt's remote_domain_get_control_info_args +type DomainGetControlInfoArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetControlInfoRet is libvirt's remote_domain_get_control_info_ret +type DomainGetControlInfoRet struct { + State uint32 + Details uint32 + StateTime uint64 +} + +// DomainOpenGraphicsArgs is libvirt's remote_domain_open_graphics_args +type DomainOpenGraphicsArgs struct { + Dom Domain + Idx uint32 + Flags DomainOpenGraphicsFlags +} + +// DomainOpenGraphicsFdArgs is libvirt's remote_domain_open_graphics_fd_args +type DomainOpenGraphicsFdArgs struct { + Dom Domain + Idx uint32 + Flags DomainOpenGraphicsFlags +} + +// NodeSuspendForDurationArgs is libvirt's remote_node_suspend_for_duration_args +type NodeSuspendForDurationArgs struct { + Target uint32 + Duration uint64 + Flags uint32 +} + +// DomainShutdownFlagsArgs is libvirt's remote_domain_shutdown_flags_args +type DomainShutdownFlagsArgs struct { + Dom Domain + Flags DomainShutdownFlagValues +} + +// DomainGetDiskErrorsArgs is libvirt's remote_domain_get_disk_errors_args +type DomainGetDiskErrorsArgs struct { + Dom Domain + Maxerrors uint32 + Flags uint32 +} + +// DomainGetDiskErrorsRet is libvirt's remote_domain_get_disk_errors_ret +type DomainGetDiskErrorsRet struct { + Errors []DomainDiskError + Nerrors int32 +} + +// ConnectListAllDomainsArgs is libvirt's remote_connect_list_all_domains_args +type ConnectListAllDomainsArgs struct { + NeedResults int32 + Flags ConnectListAllDomainsFlags +} + +// ConnectListAllDomainsRet is libvirt's remote_connect_list_all_domains_ret +type ConnectListAllDomainsRet struct { + Domains []Domain + Ret uint32 +} + +// ConnectListAllStoragePoolsArgs is libvirt's remote_connect_list_all_storage_pools_args +type ConnectListAllStoragePoolsArgs struct { + NeedResults int32 + Flags ConnectListAllStoragePoolsFlags +} + +// ConnectListAllStoragePoolsRet is libvirt's remote_connect_list_all_storage_pools_ret +type ConnectListAllStoragePoolsRet struct { + Pools []StoragePool + Ret uint32 +} + +// StoragePoolListAllVolumesArgs is libvirt's remote_storage_pool_list_all_volumes_args +type StoragePoolListAllVolumesArgs struct { + Pool StoragePool + NeedResults int32 + Flags uint32 +} + +// StoragePoolListAllVolumesRet is libvirt's remote_storage_pool_list_all_volumes_ret +type StoragePoolListAllVolumesRet struct { + Vols []StorageVol + Ret uint32 +} + +// ConnectListAllNetworksArgs is libvirt's remote_connect_list_all_networks_args +type ConnectListAllNetworksArgs struct { + NeedResults int32 + Flags ConnectListAllNetworksFlags +} + +// ConnectListAllNetworksRet is libvirt's remote_connect_list_all_networks_ret +type ConnectListAllNetworksRet struct { + Nets []Network + Ret uint32 +} + +// ConnectListAllInterfacesArgs is libvirt's remote_connect_list_all_interfaces_args +type ConnectListAllInterfacesArgs struct { + NeedResults int32 + Flags ConnectListAllInterfacesFlags +} + +// ConnectListAllInterfacesRet is libvirt's remote_connect_list_all_interfaces_ret +type ConnectListAllInterfacesRet struct { + Ifaces []Interface + Ret uint32 +} + +// ConnectListAllNodeDevicesArgs is libvirt's remote_connect_list_all_node_devices_args +type ConnectListAllNodeDevicesArgs struct { + NeedResults int32 + Flags uint32 +} + +// ConnectListAllNodeDevicesRet is libvirt's remote_connect_list_all_node_devices_ret +type ConnectListAllNodeDevicesRet struct { + Devices []NodeDevice + Ret uint32 +} + +// ConnectListAllNwfiltersArgs is libvirt's remote_connect_list_all_nwfilters_args +type ConnectListAllNwfiltersArgs struct { + NeedResults int32 + Flags uint32 +} + +// ConnectListAllNwfiltersRet is libvirt's remote_connect_list_all_nwfilters_ret +type ConnectListAllNwfiltersRet struct { + Filters []Nwfilter + Ret uint32 +} + +// ConnectListAllSecretsArgs is libvirt's remote_connect_list_all_secrets_args +type ConnectListAllSecretsArgs struct { + NeedResults int32 + Flags ConnectListAllSecretsFlags +} + +// ConnectListAllSecretsRet is libvirt's remote_connect_list_all_secrets_ret +type ConnectListAllSecretsRet struct { + Secrets []Secret + Ret uint32 +} + +// NodeSetMemoryParametersArgs is libvirt's remote_node_set_memory_parameters_args +type NodeSetMemoryParametersArgs struct { + Params []TypedParam + Flags uint32 +} + +// NodeGetMemoryParametersArgs is libvirt's remote_node_get_memory_parameters_args +type NodeGetMemoryParametersArgs struct { + Nparams int32 + Flags uint32 +} + +// NodeGetMemoryParametersRet is libvirt's remote_node_get_memory_parameters_ret +type NodeGetMemoryParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// NodeGetCPUMapArgs is libvirt's remote_node_get_cpu_map_args +type NodeGetCPUMapArgs struct { + NeedMap int32 + NeedOnline int32 + Flags uint32 +} + +// NodeGetCPUMapRet is libvirt's remote_node_get_cpu_map_ret +type NodeGetCPUMapRet struct { + Cpumap []byte + Online uint32 + Ret int32 +} + +// DomainFstrimArgs is libvirt's remote_domain_fstrim_args +type DomainFstrimArgs struct { + Dom Domain + MountPoint OptString + Minimum uint64 + Flags uint32 +} + +// DomainGetTimeArgs is libvirt's remote_domain_get_time_args +type DomainGetTimeArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetTimeRet is libvirt's remote_domain_get_time_ret +type DomainGetTimeRet struct { + Seconds int64 + Nseconds uint32 +} + +// DomainSetTimeArgs is libvirt's remote_domain_set_time_args +type DomainSetTimeArgs struct { + Dom Domain + Seconds int64 + Nseconds uint32 + Flags DomainSetTimeFlags +} + +// DomainMigrateBegin3ParamsArgs is libvirt's remote_domain_migrate_begin3_params_args +type DomainMigrateBegin3ParamsArgs struct { + Dom Domain + Params []TypedParam + Flags uint32 +} + +// DomainMigrateBegin3ParamsRet is libvirt's remote_domain_migrate_begin3_params_ret +type DomainMigrateBegin3ParamsRet struct { + CookieOut []byte + XML string +} + +// DomainMigratePrepare3ParamsArgs is libvirt's remote_domain_migrate_prepare3_params_args +type DomainMigratePrepare3ParamsArgs struct { + Params []TypedParam + CookieIn []byte + Flags uint32 +} + +// DomainMigratePrepare3ParamsRet is libvirt's remote_domain_migrate_prepare3_params_ret +type DomainMigratePrepare3ParamsRet struct { + CookieOut []byte + UriOut OptString +} + +// DomainMigratePrepareTunnel3ParamsArgs is libvirt's remote_domain_migrate_prepare_tunnel3_params_args +type DomainMigratePrepareTunnel3ParamsArgs struct { + Params []TypedParam + CookieIn []byte + Flags uint32 +} + +// DomainMigratePrepareTunnel3ParamsRet is libvirt's remote_domain_migrate_prepare_tunnel3_params_ret +type DomainMigratePrepareTunnel3ParamsRet struct { + CookieOut []byte +} + +// DomainMigratePerform3ParamsArgs is libvirt's remote_domain_migrate_perform3_params_args +type DomainMigratePerform3ParamsArgs struct { + Dom Domain + Dconnuri OptString + Params []TypedParam + CookieIn []byte + Flags DomainMigrateFlags +} + +// DomainMigratePerform3ParamsRet is libvirt's remote_domain_migrate_perform3_params_ret +type DomainMigratePerform3ParamsRet struct { + CookieOut []byte +} + +// DomainMigrateFinish3ParamsArgs is libvirt's remote_domain_migrate_finish3_params_args +type DomainMigrateFinish3ParamsArgs struct { + Params []TypedParam + CookieIn []byte + Flags uint32 + Cancelled int32 +} + +// DomainMigrateFinish3ParamsRet is libvirt's remote_domain_migrate_finish3_params_ret +type DomainMigrateFinish3ParamsRet struct { + Dom Domain + CookieOut []byte +} + +// DomainMigrateConfirm3ParamsArgs is libvirt's remote_domain_migrate_confirm3_params_args +type DomainMigrateConfirm3ParamsArgs struct { + Dom Domain + Params []TypedParam + CookieIn []byte + Flags uint32 + Cancelled int32 +} + +// DomainEventDeviceRemovedMsg is libvirt's remote_domain_event_device_removed_msg +type DomainEventDeviceRemovedMsg struct { + Dom Domain + DevAlias string +} + +// DomainEventCallbackDeviceRemovedMsg is libvirt's remote_domain_event_callback_device_removed_msg +type DomainEventCallbackDeviceRemovedMsg struct { + CallbackID int32 + Msg DomainEventDeviceRemovedMsg +} + +// DomainEventBlockJob2Msg is libvirt's remote_domain_event_block_job_2_msg +type DomainEventBlockJob2Msg struct { + CallbackID int32 + Dom Domain + Dst string + Type int32 + Status int32 +} + +// DomainEventBlockThresholdMsg is libvirt's remote_domain_event_block_threshold_msg +type DomainEventBlockThresholdMsg struct { + CallbackID int32 + Dom Domain + Dev string + Path OptString + Threshold uint64 + Excess uint64 +} + +// DomainEventCallbackTunableMsg is libvirt's remote_domain_event_callback_tunable_msg +type DomainEventCallbackTunableMsg struct { + CallbackID int32 + Dom Domain + Params []TypedParam +} + +// DomainEventCallbackDeviceAddedMsg is libvirt's remote_domain_event_callback_device_added_msg +type DomainEventCallbackDeviceAddedMsg struct { + CallbackID int32 + Dom Domain + DevAlias string +} + +// ConnectEventConnectionClosedMsg is libvirt's remote_connect_event_connection_closed_msg +type ConnectEventConnectionClosedMsg struct { + Reason int32 +} + +// ConnectGetCPUModelNamesArgs is libvirt's remote_connect_get_cpu_model_names_args +type ConnectGetCPUModelNamesArgs struct { + Arch string + NeedResults int32 + Flags uint32 +} + +// ConnectGetCPUModelNamesRet is libvirt's remote_connect_get_cpu_model_names_ret +type ConnectGetCPUModelNamesRet struct { + Models []string + Ret int32 +} + +// ConnectNetworkEventRegisterAnyArgs is libvirt's remote_connect_network_event_register_any_args +type ConnectNetworkEventRegisterAnyArgs struct { + EventID int32 + Net OptNetwork +} + +// ConnectNetworkEventRegisterAnyRet is libvirt's remote_connect_network_event_register_any_ret +type ConnectNetworkEventRegisterAnyRet struct { + CallbackID int32 +} + +// ConnectNetworkEventDeregisterAnyArgs is libvirt's remote_connect_network_event_deregister_any_args +type ConnectNetworkEventDeregisterAnyArgs struct { + CallbackID int32 +} + +// NetworkEventLifecycleMsg is libvirt's remote_network_event_lifecycle_msg +type NetworkEventLifecycleMsg struct { + CallbackID int32 + Net Network + Event int32 + Detail int32 +} + +// ConnectStoragePoolEventRegisterAnyArgs is libvirt's remote_connect_storage_pool_event_register_any_args +type ConnectStoragePoolEventRegisterAnyArgs struct { + EventID int32 + Pool OptStoragePool +} + +// ConnectStoragePoolEventRegisterAnyRet is libvirt's remote_connect_storage_pool_event_register_any_ret +type ConnectStoragePoolEventRegisterAnyRet struct { + CallbackID int32 +} + +// ConnectStoragePoolEventDeregisterAnyArgs is libvirt's remote_connect_storage_pool_event_deregister_any_args +type ConnectStoragePoolEventDeregisterAnyArgs struct { + CallbackID int32 +} + +// StoragePoolEventLifecycleMsg is libvirt's remote_storage_pool_event_lifecycle_msg +type StoragePoolEventLifecycleMsg struct { + CallbackID int32 + Pool StoragePool + Event int32 + Detail int32 +} + +// StoragePoolEventRefreshMsg is libvirt's remote_storage_pool_event_refresh_msg +type StoragePoolEventRefreshMsg struct { + CallbackID int32 + Pool StoragePool +} + +// ConnectNodeDeviceEventRegisterAnyArgs is libvirt's remote_connect_node_device_event_register_any_args +type ConnectNodeDeviceEventRegisterAnyArgs struct { + EventID int32 + Dev OptNodeDevice +} + +// ConnectNodeDeviceEventRegisterAnyRet is libvirt's remote_connect_node_device_event_register_any_ret +type ConnectNodeDeviceEventRegisterAnyRet struct { + CallbackID int32 +} + +// ConnectNodeDeviceEventDeregisterAnyArgs is libvirt's remote_connect_node_device_event_deregister_any_args +type ConnectNodeDeviceEventDeregisterAnyArgs struct { + CallbackID int32 +} + +// NodeDeviceEventLifecycleMsg is libvirt's remote_node_device_event_lifecycle_msg +type NodeDeviceEventLifecycleMsg struct { + CallbackID int32 + Dev NodeDevice + Event int32 + Detail int32 +} + +// NodeDeviceEventUpdateMsg is libvirt's remote_node_device_event_update_msg +type NodeDeviceEventUpdateMsg struct { + CallbackID int32 + Dev NodeDevice +} + +// DomainFsfreezeArgs is libvirt's remote_domain_fsfreeze_args +type DomainFsfreezeArgs struct { + Dom Domain + Mountpoints []string + Flags uint32 +} + +// DomainFsfreezeRet is libvirt's remote_domain_fsfreeze_ret +type DomainFsfreezeRet struct { + Filesystems int32 +} + +// DomainFsthawArgs is libvirt's remote_domain_fsthaw_args +type DomainFsthawArgs struct { + Dom Domain + Mountpoints []string + Flags uint32 +} + +// DomainFsthawRet is libvirt's remote_domain_fsthaw_ret +type DomainFsthawRet struct { + Filesystems int32 +} + +// NodeGetFreePagesArgs is libvirt's remote_node_get_free_pages_args +type NodeGetFreePagesArgs struct { + Pages []uint32 + StartCell int32 + CellCount uint32 + Flags uint32 +} + +// NodeGetFreePagesRet is libvirt's remote_node_get_free_pages_ret +type NodeGetFreePagesRet struct { + Counts []uint64 +} + +// NodeAllocPagesArgs is libvirt's remote_node_alloc_pages_args +type NodeAllocPagesArgs struct { + PageSizes []uint32 + PageCounts []uint64 + StartCell int32 + CellCount uint32 + Flags NodeAllocPagesFlags +} + +// NodeAllocPagesRet is libvirt's remote_node_alloc_pages_ret +type NodeAllocPagesRet struct { + Ret int32 +} + +// NetworkDhcpLease is libvirt's remote_network_dhcp_lease +type NetworkDhcpLease struct { + Iface string + Expirytime int64 + Type int32 + Mac OptString + Iaid OptString + Ipaddr string + Prefix uint32 + Hostname OptString + Clientid OptString +} + +// NetworkGetDhcpLeasesArgs is libvirt's remote_network_get_dhcp_leases_args +type NetworkGetDhcpLeasesArgs struct { + Net Network + Mac OptString + NeedResults int32 + Flags uint32 +} + +// NetworkGetDhcpLeasesRet is libvirt's remote_network_get_dhcp_leases_ret +type NetworkGetDhcpLeasesRet struct { + Leases []NetworkDhcpLease + Ret uint32 +} + +// DomainStatsRecord is libvirt's remote_domain_stats_record +type DomainStatsRecord struct { + Dom Domain + Params []TypedParam +} + +// ConnectGetAllDomainStatsArgs is libvirt's remote_connect_get_all_domain_stats_args +type ConnectGetAllDomainStatsArgs struct { + Doms []Domain + Stats uint32 + Flags ConnectGetAllDomainStatsFlags +} + +// DomainEventCallbackAgentLifecycleMsg is libvirt's remote_domain_event_callback_agent_lifecycle_msg +type DomainEventCallbackAgentLifecycleMsg struct { + CallbackID int32 + Dom Domain + State int32 + Reason int32 +} + +// ConnectGetAllDomainStatsRet is libvirt's remote_connect_get_all_domain_stats_ret +type ConnectGetAllDomainStatsRet struct { + RetStats []DomainStatsRecord +} + +// DomainFsinfo is libvirt's remote_domain_fsinfo +type DomainFsinfo struct { + Mountpoint string + Name string + Fstype string + DevAliases []string +} + +// DomainGetFsinfoArgs is libvirt's remote_domain_get_fsinfo_args +type DomainGetFsinfoArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetFsinfoRet is libvirt's remote_domain_get_fsinfo_ret +type DomainGetFsinfoRet struct { + Info []DomainFsinfo + Ret uint32 +} + +// DomainIPAddr is libvirt's remote_domain_ip_addr +type DomainIPAddr struct { + Type int32 + Addr string + Prefix uint32 +} + +// DomainInterface is libvirt's remote_domain_interface +type DomainInterface struct { + Name string + Hwaddr OptString + Addrs []DomainIPAddr +} + +// DomainInterfaceAddressesArgs is libvirt's remote_domain_interface_addresses_args +type DomainInterfaceAddressesArgs struct { + Dom Domain + Source uint32 + Flags uint32 +} + +// DomainInterfaceAddressesRet is libvirt's remote_domain_interface_addresses_ret +type DomainInterfaceAddressesRet struct { + Ifaces []DomainInterface +} + +// DomainSetUserPasswordArgs is libvirt's remote_domain_set_user_password_args +type DomainSetUserPasswordArgs struct { + Dom Domain + User OptString + Password OptString + Flags DomainSetUserPasswordFlags +} + +// DomainRenameArgs is libvirt's remote_domain_rename_args +type DomainRenameArgs struct { + Dom Domain + NewName OptString + Flags uint32 +} + +// DomainRenameRet is libvirt's remote_domain_rename_ret +type DomainRenameRet struct { + Retcode int32 +} + +// DomainEventCallbackMigrationIterationMsg is libvirt's remote_domain_event_callback_migration_iteration_msg +type DomainEventCallbackMigrationIterationMsg struct { + CallbackID int32 + Dom Domain + Iteration int32 +} + +// DomainEventCallbackJobCompletedMsg is libvirt's remote_domain_event_callback_job_completed_msg +type DomainEventCallbackJobCompletedMsg struct { + CallbackID int32 + Dom Domain + Params []TypedParam +} + +// DomainMigrateStartPostCopyArgs is libvirt's remote_domain_migrate_start_post_copy_args +type DomainMigrateStartPostCopyArgs struct { + Dom Domain + Flags uint32 +} + +// DomainEventCallbackDeviceRemovalFailedMsg is libvirt's remote_domain_event_callback_device_removal_failed_msg +type DomainEventCallbackDeviceRemovalFailedMsg struct { + CallbackID int32 + Dom Domain + DevAlias string +} + +// DomainGetGuestVcpusArgs is libvirt's remote_domain_get_guest_vcpus_args +type DomainGetGuestVcpusArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetGuestVcpusRet is libvirt's remote_domain_get_guest_vcpus_ret +type DomainGetGuestVcpusRet struct { + Params []TypedParam +} + +// DomainSetGuestVcpusArgs is libvirt's remote_domain_set_guest_vcpus_args +type DomainSetGuestVcpusArgs struct { + Dom Domain + Cpumap string + State int32 + Flags uint32 +} + +// DomainSetVcpuArgs is libvirt's remote_domain_set_vcpu_args +type DomainSetVcpuArgs struct { + Dom Domain + Cpumap string + State int32 + Flags DomainModificationImpact +} + +// DomainEventCallbackMetadataChangeMsg is libvirt's remote_domain_event_callback_metadata_change_msg +type DomainEventCallbackMetadataChangeMsg struct { + CallbackID int32 + Dom Domain + Type int32 + Nsuri OptString +} + +// DomainEventMemoryFailureMsg is libvirt's remote_domain_event_memory_failure_msg +type DomainEventMemoryFailureMsg struct { + CallbackID int32 + Dom Domain + Recipient int32 + Action int32 + Flags uint32 +} + +// ConnectSecretEventRegisterAnyArgs is libvirt's remote_connect_secret_event_register_any_args +type ConnectSecretEventRegisterAnyArgs struct { + EventID int32 + OptSecret OptSecret +} + +// ConnectSecretEventRegisterAnyRet is libvirt's remote_connect_secret_event_register_any_ret +type ConnectSecretEventRegisterAnyRet struct { + CallbackID int32 +} + +// ConnectSecretEventDeregisterAnyArgs is libvirt's remote_connect_secret_event_deregister_any_args +type ConnectSecretEventDeregisterAnyArgs struct { + CallbackID int32 +} + +// SecretEventLifecycleMsg is libvirt's remote_secret_event_lifecycle_msg +type SecretEventLifecycleMsg struct { + CallbackID int32 + OptSecret Secret + Event int32 + Detail int32 +} + +// SecretEventValueChangedMsg is libvirt's remote_secret_event_value_changed_msg +type SecretEventValueChangedMsg struct { + CallbackID int32 + OptSecret Secret +} + +// DomainSetBlockThresholdArgs is libvirt's remote_domain_set_block_threshold_args +type DomainSetBlockThresholdArgs struct { + Dom Domain + Dev string + Threshold uint64 + Flags uint32 +} + +// DomainSetLifecycleActionArgs is libvirt's remote_domain_set_lifecycle_action_args +type DomainSetLifecycleActionArgs struct { + Dom Domain + Type uint32 + Action uint32 + Flags DomainModificationImpact +} + +// ConnectCompareHypervisorCPUArgs is libvirt's remote_connect_compare_hypervisor_cpu_args +type ConnectCompareHypervisorCPUArgs struct { + Emulator OptString + Arch OptString + Machine OptString + Virttype OptString + XMLCPU string + Flags uint32 +} + +// ConnectCompareHypervisorCPURet is libvirt's remote_connect_compare_hypervisor_cpu_ret +type ConnectCompareHypervisorCPURet struct { + Result int32 +} + +// ConnectBaselineHypervisorCPUArgs is libvirt's remote_connect_baseline_hypervisor_cpu_args +type ConnectBaselineHypervisorCPUArgs struct { + Emulator OptString + Arch OptString + Machine OptString + Virttype OptString + XMLCPUs []string + Flags uint32 +} + +// ConnectBaselineHypervisorCPURet is libvirt's remote_connect_baseline_hypervisor_cpu_ret +type ConnectBaselineHypervisorCPURet struct { + CPU string +} + +// NodeGetSevInfoArgs is libvirt's remote_node_get_sev_info_args +type NodeGetSevInfoArgs struct { + Nparams int32 + Flags uint32 +} + +// NodeGetSevInfoRet is libvirt's remote_node_get_sev_info_ret +type NodeGetSevInfoRet struct { + Params []TypedParam + Nparams int32 +} + +// DomainGetLaunchSecurityInfoArgs is libvirt's remote_domain_get_launch_security_info_args +type DomainGetLaunchSecurityInfoArgs struct { + Dom Domain + Flags uint32 +} + +// DomainGetLaunchSecurityInfoRet is libvirt's remote_domain_get_launch_security_info_ret +type DomainGetLaunchSecurityInfoRet struct { + Params []TypedParam +} + +// NwfilterBindingLookupByPortDevArgs is libvirt's remote_nwfilter_binding_lookup_by_port_dev_args +type NwfilterBindingLookupByPortDevArgs struct { + Name string +} + +// NwfilterBindingLookupByPortDevRet is libvirt's remote_nwfilter_binding_lookup_by_port_dev_ret +type NwfilterBindingLookupByPortDevRet struct { + OptNwfilter NwfilterBinding +} + +// NwfilterBindingCreateXMLArgs is libvirt's remote_nwfilter_binding_create_xml_args +type NwfilterBindingCreateXMLArgs struct { + XML string + Flags uint32 +} + +// NwfilterBindingCreateXMLRet is libvirt's remote_nwfilter_binding_create_xml_ret +type NwfilterBindingCreateXMLRet struct { + OptNwfilter NwfilterBinding +} + +// NwfilterBindingDeleteArgs is libvirt's remote_nwfilter_binding_delete_args +type NwfilterBindingDeleteArgs struct { + OptNwfilter NwfilterBinding +} + +// NwfilterBindingGetXMLDescArgs is libvirt's remote_nwfilter_binding_get_xml_desc_args +type NwfilterBindingGetXMLDescArgs struct { + OptNwfilter NwfilterBinding + Flags uint32 +} + +// NwfilterBindingGetXMLDescRet is libvirt's remote_nwfilter_binding_get_xml_desc_ret +type NwfilterBindingGetXMLDescRet struct { + XML string +} + +// ConnectListAllNwfilterBindingsArgs is libvirt's remote_connect_list_all_nwfilter_bindings_args +type ConnectListAllNwfilterBindingsArgs struct { + NeedResults int32 + Flags uint32 +} + +// ConnectListAllNwfilterBindingsRet is libvirt's remote_connect_list_all_nwfilter_bindings_ret +type ConnectListAllNwfilterBindingsRet struct { + Bindings []NwfilterBinding + Ret uint32 +} + +// ConnectGetStoragePoolCapabilitiesArgs is libvirt's remote_connect_get_storage_pool_capabilities_args +type ConnectGetStoragePoolCapabilitiesArgs struct { + Flags uint32 +} + +// ConnectGetStoragePoolCapabilitiesRet is libvirt's remote_connect_get_storage_pool_capabilities_ret +type ConnectGetStoragePoolCapabilitiesRet struct { + Capabilities string +} + +// NetworkListAllPortsArgs is libvirt's remote_network_list_all_ports_args +type NetworkListAllPortsArgs struct { + OptNetwork Network + NeedResults int32 + Flags uint32 +} + +// NetworkListAllPortsRet is libvirt's remote_network_list_all_ports_ret +type NetworkListAllPortsRet struct { + Ports []NetworkPort + Ret uint32 +} + +// NetworkPortLookupByUUIDArgs is libvirt's remote_network_port_lookup_by_uuid_args +type NetworkPortLookupByUUIDArgs struct { + OptNetwork Network + UUID UUID +} + +// NetworkPortLookupByUUIDRet is libvirt's remote_network_port_lookup_by_uuid_ret +type NetworkPortLookupByUUIDRet struct { + Port NetworkPort +} + +// NetworkPortCreateXMLArgs is libvirt's remote_network_port_create_xml_args +type NetworkPortCreateXMLArgs struct { + OptNetwork Network + XML string + Flags uint32 +} + +// NetworkPortCreateXMLRet is libvirt's remote_network_port_create_xml_ret +type NetworkPortCreateXMLRet struct { + Port NetworkPort +} + +// NetworkPortSetParametersArgs is libvirt's remote_network_port_set_parameters_args +type NetworkPortSetParametersArgs struct { + Port NetworkPort + Params []TypedParam + Flags uint32 +} + +// NetworkPortGetParametersArgs is libvirt's remote_network_port_get_parameters_args +type NetworkPortGetParametersArgs struct { + Port NetworkPort + Nparams int32 + Flags uint32 +} + +// NetworkPortGetParametersRet is libvirt's remote_network_port_get_parameters_ret +type NetworkPortGetParametersRet struct { + Params []TypedParam + Nparams int32 +} + +// NetworkPortGetXMLDescArgs is libvirt's remote_network_port_get_xml_desc_args +type NetworkPortGetXMLDescArgs struct { + Port NetworkPort + Flags uint32 +} + +// NetworkPortGetXMLDescRet is libvirt's remote_network_port_get_xml_desc_ret +type NetworkPortGetXMLDescRet struct { + XML string +} + +// NetworkPortDeleteArgs is libvirt's remote_network_port_delete_args +type NetworkPortDeleteArgs struct { + Port NetworkPort + Flags uint32 +} + +// DomainCheckpointCreateXMLArgs is libvirt's remote_domain_checkpoint_create_xml_args +type DomainCheckpointCreateXMLArgs struct { + Dom Domain + XMLDesc string + Flags uint32 +} + +// DomainCheckpointCreateXMLRet is libvirt's remote_domain_checkpoint_create_xml_ret +type DomainCheckpointCreateXMLRet struct { + Checkpoint DomainCheckpoint +} + +// DomainCheckpointGetXMLDescArgs is libvirt's remote_domain_checkpoint_get_xml_desc_args +type DomainCheckpointGetXMLDescArgs struct { + Checkpoint DomainCheckpoint + Flags uint32 +} + +// DomainCheckpointGetXMLDescRet is libvirt's remote_domain_checkpoint_get_xml_desc_ret +type DomainCheckpointGetXMLDescRet struct { + XML string +} + +// DomainListAllCheckpointsArgs is libvirt's remote_domain_list_all_checkpoints_args +type DomainListAllCheckpointsArgs struct { + Dom Domain + NeedResults int32 + Flags uint32 +} + +// DomainListAllCheckpointsRet is libvirt's remote_domain_list_all_checkpoints_ret +type DomainListAllCheckpointsRet struct { + Checkpoints []DomainCheckpoint + Ret int32 +} + +// DomainCheckpointListAllChildrenArgs is libvirt's remote_domain_checkpoint_list_all_children_args +type DomainCheckpointListAllChildrenArgs struct { + Checkpoint DomainCheckpoint + NeedResults int32 + Flags uint32 +} + +// DomainCheckpointListAllChildrenRet is libvirt's remote_domain_checkpoint_list_all_children_ret +type DomainCheckpointListAllChildrenRet struct { + Checkpoints []DomainCheckpoint + Ret int32 +} + +// DomainCheckpointLookupByNameArgs is libvirt's remote_domain_checkpoint_lookup_by_name_args +type DomainCheckpointLookupByNameArgs struct { + Dom Domain + Name string + Flags uint32 +} + +// DomainCheckpointLookupByNameRet is libvirt's remote_domain_checkpoint_lookup_by_name_ret +type DomainCheckpointLookupByNameRet struct { + Checkpoint DomainCheckpoint +} + +// DomainCheckpointGetParentArgs is libvirt's remote_domain_checkpoint_get_parent_args +type DomainCheckpointGetParentArgs struct { + Checkpoint DomainCheckpoint + Flags uint32 +} + +// DomainCheckpointGetParentRet is libvirt's remote_domain_checkpoint_get_parent_ret +type DomainCheckpointGetParentRet struct { + Parent DomainCheckpoint +} + +// DomainCheckpointDeleteArgs is libvirt's remote_domain_checkpoint_delete_args +type DomainCheckpointDeleteArgs struct { + Checkpoint DomainCheckpoint + Flags DomainCheckpointDeleteFlags +} + +// DomainGetGuestInfoArgs is libvirt's remote_domain_get_guest_info_args +type DomainGetGuestInfoArgs struct { + Dom Domain + Types uint32 + Flags uint32 +} + +// DomainGetGuestInfoRet is libvirt's remote_domain_get_guest_info_ret +type DomainGetGuestInfoRet struct { + Params []TypedParam +} + +// ConnectSetIdentityArgs is libvirt's remote_connect_set_identity_args +type ConnectSetIdentityArgs struct { + Params []TypedParam + Flags uint32 +} + +// DomainAgentSetResponseTimeoutArgs is libvirt's remote_domain_agent_set_response_timeout_args +type DomainAgentSetResponseTimeoutArgs struct { + Dom Domain + Timeout int32 + Flags uint32 +} + +// DomainAgentSetResponseTimeoutRet is libvirt's remote_domain_agent_set_response_timeout_ret +type DomainAgentSetResponseTimeoutRet struct { + Result int32 +} + +// DomainBackupBeginArgs is libvirt's remote_domain_backup_begin_args +type DomainBackupBeginArgs struct { + Dom Domain + BackupXML string + CheckpointXML OptString + Flags DomainBackupBeginFlags +} + +// DomainBackupGetXMLDescArgs is libvirt's remote_domain_backup_get_xml_desc_args +type DomainBackupGetXMLDescArgs struct { + Dom Domain + Flags uint32 +} + +// DomainBackupGetXMLDescRet is libvirt's remote_domain_backup_get_xml_desc_ret +type DomainBackupGetXMLDescRet struct { + XML string +} + +// DomainAuthorizedSshKeysGetArgs is libvirt's remote_domain_authorized_ssh_keys_get_args +type DomainAuthorizedSshKeysGetArgs struct { + Dom Domain + User string + Flags uint32 +} + +// DomainAuthorizedSshKeysGetRet is libvirt's remote_domain_authorized_ssh_keys_get_ret +type DomainAuthorizedSshKeysGetRet struct { + Keys []string +} + +// DomainAuthorizedSshKeysSetArgs is libvirt's remote_domain_authorized_ssh_keys_set_args +type DomainAuthorizedSshKeysSetArgs struct { + Dom Domain + User string + Keys []string + Flags uint32 +} + + +// TypedParamValue is a discriminated union. +type TypedParamValue struct { + D uint32 + I interface{} +} + +// NewTypedParamValueInt creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueInt(v int32) *TypedParamValue { + return &TypedParamValue{D: 1, I: v} +} + +// NewTypedParamValueUint creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueUint(v uint32) *TypedParamValue { + return &TypedParamValue{D: 2, I: v} +} + +// NewTypedParamValueLlong creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueLlong(v int64) *TypedParamValue { + return &TypedParamValue{D: 3, I: v} +} + +// NewTypedParamValueUllong creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueUllong(v uint64) *TypedParamValue { + return &TypedParamValue{D: 4, I: v} +} + +// NewTypedParamValueDouble creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueDouble(v float64) *TypedParamValue { + return &TypedParamValue{D: 5, I: v} +} + +// NewTypedParamValueBoolean creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueBoolean(v int32) *TypedParamValue { + return &TypedParamValue{D: 6, I: v} +} + +// NewTypedParamValueString creates a discriminated union value satisfying +// the TypedParamValue interface. +func NewTypedParamValueString(v string) *TypedParamValue { + return &TypedParamValue{D: 7, I: v} +} + + +// ConnectOpen is the go wrapper for REMOTE_PROC_CONNECT_OPEN. +func (l *Libvirt) ConnectOpen(Name OptString, Flags ConnectFlags) (err error) { + var buf []byte + + args := ConnectOpenArgs { + Name: Name, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(1, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectClose is the go wrapper for REMOTE_PROC_CONNECT_CLOSE. +func (l *Libvirt) ConnectClose() (err error) { + var buf []byte + + + _, err = l.requestStream(2, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectGetType is the go wrapper for REMOTE_PROC_CONNECT_GET_TYPE. +func (l *Libvirt) ConnectGetType() (rType string, err error) { + var buf []byte + + var r response + r, err = l.requestStream(3, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: string + _, err = dec.Decode(&rType) + if err != nil { + return + } + + return +} + +// ConnectGetVersion is the go wrapper for REMOTE_PROC_CONNECT_GET_VERSION. +func (l *Libvirt) ConnectGetVersion() (rHvVer uint64, err error) { + var buf []byte + + var r response + r, err = l.requestStream(4, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // HvVer: uint64 + _, err = dec.Decode(&rHvVer) + if err != nil { + return + } + + return +} + +// ConnectGetMaxVcpus is the go wrapper for REMOTE_PROC_CONNECT_GET_MAX_VCPUS. +func (l *Libvirt) ConnectGetMaxVcpus(Type OptString) (rMaxVcpus int32, err error) { + var buf []byte + + args := ConnectGetMaxVcpusArgs { + Type: Type, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(5, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // MaxVcpus: int32 + _, err = dec.Decode(&rMaxVcpus) + if err != nil { + return + } + + return +} + +// NodeGetInfo is the go wrapper for REMOTE_PROC_NODE_GET_INFO. +func (l *Libvirt) NodeGetInfo() (rModel [32]int8, rMemory uint64, rCpus int32, rMhz int32, rNodes int32, rSockets int32, rCores int32, rThreads int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(6, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Model: [32]int8 + _, err = dec.Decode(&rModel) + if err != nil { + return + } + // Memory: uint64 + _, err = dec.Decode(&rMemory) + if err != nil { + return + } + // Cpus: int32 + _, err = dec.Decode(&rCpus) + if err != nil { + return + } + // Mhz: int32 + _, err = dec.Decode(&rMhz) + if err != nil { + return + } + // Nodes: int32 + _, err = dec.Decode(&rNodes) + if err != nil { + return + } + // Sockets: int32 + _, err = dec.Decode(&rSockets) + if err != nil { + return + } + // Cores: int32 + _, err = dec.Decode(&rCores) + if err != nil { + return + } + // Threads: int32 + _, err = dec.Decode(&rThreads) + if err != nil { + return + } + + return +} + +// ConnectGetCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_CAPABILITIES. +func (l *Libvirt) ConnectGetCapabilities() (rCapabilities string, err error) { + var buf []byte + + var r response + r, err = l.requestStream(7, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Capabilities: string + _, err = dec.Decode(&rCapabilities) + if err != nil { + return + } + + return +} + +// DomainAttachDevice is the go wrapper for REMOTE_PROC_DOMAIN_ATTACH_DEVICE. +func (l *Libvirt) DomainAttachDevice(Dom Domain, XML string) (err error) { + var buf []byte + + args := DomainAttachDeviceArgs { + Dom: Dom, + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(8, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCreate is the go wrapper for REMOTE_PROC_DOMAIN_CREATE. +func (l *Libvirt) DomainCreate(Dom Domain) (err error) { + var buf []byte + + args := DomainCreateArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(9, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_XML. +func (l *Libvirt) DomainCreateXML(XMLDesc string, Flags DomainCreateFlags) (rDom Domain, err error) { + var buf []byte + + args := DomainCreateXMLArgs { + XMLDesc: XMLDesc, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(10, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_DEFINE_XML. +func (l *Libvirt) DomainDefineXML(XML string) (rDom Domain, err error) { + var buf []byte + + args := DomainDefineXMLArgs { + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(11, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainDestroy is the go wrapper for REMOTE_PROC_DOMAIN_DESTROY. +func (l *Libvirt) DomainDestroy(Dom Domain) (err error) { + var buf []byte + + args := DomainDestroyArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(12, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainDetachDevice is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE. +func (l *Libvirt) DomainDetachDevice(Dom Domain, XML string) (err error) { + var buf []byte + + args := DomainDetachDeviceArgs { + Dom: Dom, + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(13, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_GET_XML_DESC. +func (l *Libvirt) DomainGetXMLDesc(Dom Domain, Flags DomainXMLFlags) (rXML string, err error) { + var buf []byte + + args := DomainGetXMLDescArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(14, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainGetAutostart is the go wrapper for REMOTE_PROC_DOMAIN_GET_AUTOSTART. +func (l *Libvirt) DomainGetAutostart(Dom Domain) (rAutostart int32, err error) { + var buf []byte + + args := DomainGetAutostartArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(15, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Autostart: int32 + _, err = dec.Decode(&rAutostart) + if err != nil { + return + } + + return +} + +// DomainGetInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_INFO. +func (l *Libvirt) DomainGetInfo(Dom Domain) (rState uint8, rMaxMem uint64, rMemory uint64, rNrVirtCPU uint16, rCPUTime uint64, err error) { + var buf []byte + + args := DomainGetInfoArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(16, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // State: uint8 + _, err = dec.Decode(&rState) + if err != nil { + return + } + // MaxMem: uint64 + _, err = dec.Decode(&rMaxMem) + if err != nil { + return + } + // Memory: uint64 + _, err = dec.Decode(&rMemory) + if err != nil { + return + } + // NrVirtCPU: uint16 + _, err = dec.Decode(&rNrVirtCPU) + if err != nil { + return + } + // CPUTime: uint64 + _, err = dec.Decode(&rCPUTime) + if err != nil { + return + } + + return +} + +// DomainGetMaxMemory is the go wrapper for REMOTE_PROC_DOMAIN_GET_MAX_MEMORY. +func (l *Libvirt) DomainGetMaxMemory(Dom Domain) (rMemory uint64, err error) { + var buf []byte + + args := DomainGetMaxMemoryArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(17, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Memory: uint64 + _, err = dec.Decode(&rMemory) + if err != nil { + return + } + + return +} + +// DomainGetMaxVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_MAX_VCPUS. +func (l *Libvirt) DomainGetMaxVcpus(Dom Domain) (rNum int32, err error) { + var buf []byte + + args := DomainGetMaxVcpusArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(18, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainGetOsType is the go wrapper for REMOTE_PROC_DOMAIN_GET_OS_TYPE. +func (l *Libvirt) DomainGetOsType(Dom Domain) (rType string, err error) { + var buf []byte + + args := DomainGetOsTypeArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(19, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: string + _, err = dec.Decode(&rType) + if err != nil { + return + } + + return +} + +// DomainGetVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPUS. +func (l *Libvirt) DomainGetVcpus(Dom Domain, Maxinfo int32, Maplen int32) (rInfo []VcpuInfo, rCpumaps []byte, err error) { + var buf []byte + + args := DomainGetVcpusArgs { + Dom: Dom, + Maxinfo: Maxinfo, + Maplen: Maplen, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(20, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Info: []VcpuInfo + _, err = dec.Decode(&rInfo) + if err != nil { + return + } + // Cpumaps: []byte + _, err = dec.Decode(&rCpumaps) + if err != nil { + return + } + + return +} + +// ConnectListDefinedDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_DOMAINS. +func (l *Libvirt) ConnectListDefinedDomains(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListDefinedDomainsArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(21, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// DomainLookupByID is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_ID. +func (l *Libvirt) DomainLookupByID(ID int32) (rDom Domain, err error) { + var buf []byte + + args := DomainLookupByIDArgs { + ID: ID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(22, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME. +func (l *Libvirt) DomainLookupByName(Name string) (rDom Domain, err error) { + var buf []byte + + args := DomainLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(23, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainLookupByUUID is the go wrapper for REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID. +func (l *Libvirt) DomainLookupByUUID(UUID UUID) (rDom Domain, err error) { + var buf []byte + + args := DomainLookupByUUIDArgs { + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(24, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// ConnectNumOfDefinedDomains is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_DOMAINS. +func (l *Libvirt) ConnectNumOfDefinedDomains() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(25, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainPinVcpu is the go wrapper for REMOTE_PROC_DOMAIN_PIN_VCPU. +func (l *Libvirt) DomainPinVcpu(Dom Domain, Vcpu uint32, Cpumap []byte) (err error) { + var buf []byte + + args := DomainPinVcpuArgs { + Dom: Dom, + Vcpu: Vcpu, + Cpumap: Cpumap, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(26, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainReboot is the go wrapper for REMOTE_PROC_DOMAIN_REBOOT. +func (l *Libvirt) DomainReboot(Dom Domain, Flags DomainRebootFlagValues) (err error) { + var buf []byte + + args := DomainRebootArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(27, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainResume is the go wrapper for REMOTE_PROC_DOMAIN_RESUME. +func (l *Libvirt) DomainResume(Dom Domain) (err error) { + var buf []byte + + args := DomainResumeArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(28, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetAutostart is the go wrapper for REMOTE_PROC_DOMAIN_SET_AUTOSTART. +func (l *Libvirt) DomainSetAutostart(Dom Domain, Autostart int32) (err error) { + var buf []byte + + args := DomainSetAutostartArgs { + Dom: Dom, + Autostart: Autostart, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(29, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetMaxMemory is the go wrapper for REMOTE_PROC_DOMAIN_SET_MAX_MEMORY. +func (l *Libvirt) DomainSetMaxMemory(Dom Domain, Memory uint64) (err error) { + var buf []byte + + args := DomainSetMaxMemoryArgs { + Dom: Dom, + Memory: Memory, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(30, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetMemory is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY. +func (l *Libvirt) DomainSetMemory(Dom Domain, Memory uint64) (err error) { + var buf []byte + + args := DomainSetMemoryArgs { + Dom: Dom, + Memory: Memory, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(31, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetVcpus is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPUS. +func (l *Libvirt) DomainSetVcpus(Dom Domain, Nvcpus uint32) (err error) { + var buf []byte + + args := DomainSetVcpusArgs { + Dom: Dom, + Nvcpus: Nvcpus, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(32, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainShutdown is the go wrapper for REMOTE_PROC_DOMAIN_SHUTDOWN. +func (l *Libvirt) DomainShutdown(Dom Domain) (err error) { + var buf []byte + + args := DomainShutdownArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(33, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSuspend is the go wrapper for REMOTE_PROC_DOMAIN_SUSPEND. +func (l *Libvirt) DomainSuspend(Dom Domain) (err error) { + var buf []byte + + args := DomainSuspendArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(34, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainUndefine is the go wrapper for REMOTE_PROC_DOMAIN_UNDEFINE. +func (l *Libvirt) DomainUndefine(Dom Domain) (err error) { + var buf []byte + + args := DomainUndefineArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(35, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectListDefinedNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_NETWORKS. +func (l *Libvirt) ConnectListDefinedNetworks(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListDefinedNetworksArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(36, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// ConnectListDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_DOMAINS. +func (l *Libvirt) ConnectListDomains(Maxids int32) (rIds []int32, err error) { + var buf []byte + + args := ConnectListDomainsArgs { + Maxids: Maxids, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(37, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ids: []int32 + _, err = dec.Decode(&rIds) + if err != nil { + return + } + + return +} + +// ConnectListNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_NETWORKS. +func (l *Libvirt) ConnectListNetworks(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListNetworksArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(38, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// NetworkCreate is the go wrapper for REMOTE_PROC_NETWORK_CREATE. +func (l *Libvirt) NetworkCreate(Net Network) (err error) { + var buf []byte + + args := NetworkCreateArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(39, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkCreateXML is the go wrapper for REMOTE_PROC_NETWORK_CREATE_XML. +func (l *Libvirt) NetworkCreateXML(XML string) (rNet Network, err error) { + var buf []byte + + args := NetworkCreateXMLArgs { + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(40, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Net: Network + _, err = dec.Decode(&rNet) + if err != nil { + return + } + + return +} + +// NetworkDefineXML is the go wrapper for REMOTE_PROC_NETWORK_DEFINE_XML. +func (l *Libvirt) NetworkDefineXML(XML string) (rNet Network, err error) { + var buf []byte + + args := NetworkDefineXMLArgs { + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(41, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Net: Network + _, err = dec.Decode(&rNet) + if err != nil { + return + } + + return +} + +// NetworkDestroy is the go wrapper for REMOTE_PROC_NETWORK_DESTROY. +func (l *Libvirt) NetworkDestroy(Net Network) (err error) { + var buf []byte + + args := NetworkDestroyArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(42, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkGetXMLDesc is the go wrapper for REMOTE_PROC_NETWORK_GET_XML_DESC. +func (l *Libvirt) NetworkGetXMLDesc(Net Network, Flags uint32) (rXML string, err error) { + var buf []byte + + args := NetworkGetXMLDescArgs { + Net: Net, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(43, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// NetworkGetAutostart is the go wrapper for REMOTE_PROC_NETWORK_GET_AUTOSTART. +func (l *Libvirt) NetworkGetAutostart(Net Network) (rAutostart int32, err error) { + var buf []byte + + args := NetworkGetAutostartArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(44, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Autostart: int32 + _, err = dec.Decode(&rAutostart) + if err != nil { + return + } + + return +} + +// NetworkGetBridgeName is the go wrapper for REMOTE_PROC_NETWORK_GET_BRIDGE_NAME. +func (l *Libvirt) NetworkGetBridgeName(Net Network) (rName string, err error) { + var buf []byte + + args := NetworkGetBridgeNameArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(45, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Name: string + _, err = dec.Decode(&rName) + if err != nil { + return + } + + return +} + +// NetworkLookupByName is the go wrapper for REMOTE_PROC_NETWORK_LOOKUP_BY_NAME. +func (l *Libvirt) NetworkLookupByName(Name string) (rNet Network, err error) { + var buf []byte + + args := NetworkLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(46, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Net: Network + _, err = dec.Decode(&rNet) + if err != nil { + return + } + + return +} + +// NetworkLookupByUUID is the go wrapper for REMOTE_PROC_NETWORK_LOOKUP_BY_UUID. +func (l *Libvirt) NetworkLookupByUUID(UUID UUID) (rNet Network, err error) { + var buf []byte + + args := NetworkLookupByUUIDArgs { + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(47, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Net: Network + _, err = dec.Decode(&rNet) + if err != nil { + return + } + + return +} + +// NetworkSetAutostart is the go wrapper for REMOTE_PROC_NETWORK_SET_AUTOSTART. +func (l *Libvirt) NetworkSetAutostart(Net Network, Autostart int32) (err error) { + var buf []byte + + args := NetworkSetAutostartArgs { + Net: Net, + Autostart: Autostart, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(48, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkUndefine is the go wrapper for REMOTE_PROC_NETWORK_UNDEFINE. +func (l *Libvirt) NetworkUndefine(Net Network) (err error) { + var buf []byte + + args := NetworkUndefineArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(49, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectNumOfDefinedNetworks is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_NETWORKS. +func (l *Libvirt) ConnectNumOfDefinedNetworks() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(50, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectNumOfDomains is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DOMAINS. +func (l *Libvirt) ConnectNumOfDomains() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(51, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectNumOfNetworks is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_NETWORKS. +func (l *Libvirt) ConnectNumOfNetworks() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(52, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainCoreDump is the go wrapper for REMOTE_PROC_DOMAIN_CORE_DUMP. +func (l *Libvirt) DomainCoreDump(Dom Domain, To string, Flags DomainCoreDumpFlags) (err error) { + var buf []byte + + args := DomainCoreDumpArgs { + Dom: Dom, + To: To, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(53, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainRestore is the go wrapper for REMOTE_PROC_DOMAIN_RESTORE. +func (l *Libvirt) DomainRestore(From string) (err error) { + var buf []byte + + args := DomainRestoreArgs { + From: From, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(54, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSave is the go wrapper for REMOTE_PROC_DOMAIN_SAVE. +func (l *Libvirt) DomainSave(Dom Domain, To string) (err error) { + var buf []byte + + args := DomainSaveArgs { + Dom: Dom, + To: To, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(55, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetSchedulerType is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE. +func (l *Libvirt) DomainGetSchedulerType(Dom Domain) (rType string, rNparams int32, err error) { + var buf []byte + + args := DomainGetSchedulerTypeArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(56, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: string + _, err = dec.Decode(&rType) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainGetSchedulerParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS. +func (l *Libvirt) DomainGetSchedulerParameters(Dom Domain, Nparams int32) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetSchedulerParametersArgs { + Dom: Dom, + Nparams: Nparams, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(57, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// DomainSetSchedulerParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS. +func (l *Libvirt) DomainSetSchedulerParameters(Dom Domain, Params []TypedParam) (err error) { + var buf []byte + + args := DomainSetSchedulerParametersArgs { + Dom: Dom, + Params: Params, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(58, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectGetHostname is the go wrapper for REMOTE_PROC_CONNECT_GET_HOSTNAME. +func (l *Libvirt) ConnectGetHostname() (rHostname string, err error) { + var buf []byte + + var r response + r, err = l.requestStream(59, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Hostname: string + _, err = dec.Decode(&rHostname) + if err != nil { + return + } + + return +} + +// ConnectSupportsFeature is the go wrapper for REMOTE_PROC_CONNECT_SUPPORTS_FEATURE. +func (l *Libvirt) ConnectSupportsFeature(Feature int32) (rSupported int32, err error) { + var buf []byte + + args := ConnectSupportsFeatureArgs { + Feature: Feature, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(60, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Supported: int32 + _, err = dec.Decode(&rSupported) + if err != nil { + return + } + + return +} + +// DomainMigratePrepare is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE. +func (l *Libvirt) DomainMigratePrepare(UriIn OptString, Flags uint64, Dname OptString, Resource uint64) (rCookie []byte, rUriOut OptString, err error) { + var buf []byte + + args := DomainMigratePrepareArgs { + UriIn: UriIn, + Flags: Flags, + Dname: Dname, + Resource: Resource, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(61, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cookie: []byte + _, err = dec.Decode(&rCookie) + if err != nil { + return + } + // UriOut: OptString + _, err = dec.Decode(&rUriOut) + if err != nil { + return + } + + return +} + +// DomainMigratePerform is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM. +func (l *Libvirt) DomainMigratePerform(Dom Domain, Cookie []byte, Uri string, Flags uint64, Dname OptString, Resource uint64) (err error) { + var buf []byte + + args := DomainMigratePerformArgs { + Dom: Dom, + Cookie: Cookie, + Uri: Uri, + Flags: Flags, + Dname: Dname, + Resource: Resource, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(62, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateFinish is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH. +func (l *Libvirt) DomainMigrateFinish(Dname string, Cookie []byte, Uri string, Flags uint64) (rDdom Domain, err error) { + var buf []byte + + args := DomainMigrateFinishArgs { + Dname: Dname, + Cookie: Cookie, + Uri: Uri, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(63, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ddom: Domain + _, err = dec.Decode(&rDdom) + if err != nil { + return + } + + return +} + +// DomainBlockStats is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_STATS. +func (l *Libvirt) DomainBlockStats(Dom Domain, Path string) (rRdReq int64, rRdBytes int64, rWrReq int64, rWrBytes int64, rErrs int64, err error) { + var buf []byte + + args := DomainBlockStatsArgs { + Dom: Dom, + Path: Path, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(64, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // RdReq: int64 + _, err = dec.Decode(&rRdReq) + if err != nil { + return + } + // RdBytes: int64 + _, err = dec.Decode(&rRdBytes) + if err != nil { + return + } + // WrReq: int64 + _, err = dec.Decode(&rWrReq) + if err != nil { + return + } + // WrBytes: int64 + _, err = dec.Decode(&rWrBytes) + if err != nil { + return + } + // Errs: int64 + _, err = dec.Decode(&rErrs) + if err != nil { + return + } + + return +} + +// DomainInterfaceStats is the go wrapper for REMOTE_PROC_DOMAIN_INTERFACE_STATS. +func (l *Libvirt) DomainInterfaceStats(Dom Domain, Device string) (rRxBytes int64, rRxPackets int64, rRxErrs int64, rRxDrop int64, rTxBytes int64, rTxPackets int64, rTxErrs int64, rTxDrop int64, err error) { + var buf []byte + + args := DomainInterfaceStatsArgs { + Dom: Dom, + Device: Device, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(65, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // RxBytes: int64 + _, err = dec.Decode(&rRxBytes) + if err != nil { + return + } + // RxPackets: int64 + _, err = dec.Decode(&rRxPackets) + if err != nil { + return + } + // RxErrs: int64 + _, err = dec.Decode(&rRxErrs) + if err != nil { + return + } + // RxDrop: int64 + _, err = dec.Decode(&rRxDrop) + if err != nil { + return + } + // TxBytes: int64 + _, err = dec.Decode(&rTxBytes) + if err != nil { + return + } + // TxPackets: int64 + _, err = dec.Decode(&rTxPackets) + if err != nil { + return + } + // TxErrs: int64 + _, err = dec.Decode(&rTxErrs) + if err != nil { + return + } + // TxDrop: int64 + _, err = dec.Decode(&rTxDrop) + if err != nil { + return + } + + return +} + +// AuthList is the go wrapper for REMOTE_PROC_AUTH_LIST. +func (l *Libvirt) AuthList() (rTypes []AuthType, err error) { + var buf []byte + + var r response + r, err = l.requestStream(66, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Types: []AuthType + _, err = dec.Decode(&rTypes) + if err != nil { + return + } + + return +} + +// AuthSaslInit is the go wrapper for REMOTE_PROC_AUTH_SASL_INIT. +func (l *Libvirt) AuthSaslInit() (rMechlist string, err error) { + var buf []byte + + var r response + r, err = l.requestStream(67, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Mechlist: string + _, err = dec.Decode(&rMechlist) + if err != nil { + return + } + + return +} + +// AuthSaslStart is the go wrapper for REMOTE_PROC_AUTH_SASL_START. +func (l *Libvirt) AuthSaslStart(Mech string, Nil int32, Data []int8) (rComplete int32, rNil int32, rData []int8, err error) { + var buf []byte + + args := AuthSaslStartArgs { + Mech: Mech, + Nil: Nil, + Data: Data, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(68, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Complete: int32 + _, err = dec.Decode(&rComplete) + if err != nil { + return + } + // Nil: int32 + _, err = dec.Decode(&rNil) + if err != nil { + return + } + // Data: []int8 + _, err = dec.Decode(&rData) + if err != nil { + return + } + + return +} + +// AuthSaslStep is the go wrapper for REMOTE_PROC_AUTH_SASL_STEP. +func (l *Libvirt) AuthSaslStep(Nil int32, Data []int8) (rComplete int32, rNil int32, rData []int8, err error) { + var buf []byte + + args := AuthSaslStepArgs { + Nil: Nil, + Data: Data, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(69, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Complete: int32 + _, err = dec.Decode(&rComplete) + if err != nil { + return + } + // Nil: int32 + _, err = dec.Decode(&rNil) + if err != nil { + return + } + // Data: []int8 + _, err = dec.Decode(&rData) + if err != nil { + return + } + + return +} + +// AuthPolkit is the go wrapper for REMOTE_PROC_AUTH_POLKIT. +func (l *Libvirt) AuthPolkit() (rComplete int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(70, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Complete: int32 + _, err = dec.Decode(&rComplete) + if err != nil { + return + } + + return +} + +// ConnectNumOfStoragePools is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_STORAGE_POOLS. +func (l *Libvirt) ConnectNumOfStoragePools() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(71, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_STORAGE_POOLS. +func (l *Libvirt) ConnectListStoragePools(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListStoragePoolsArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(72, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// ConnectNumOfDefinedStoragePools is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_STORAGE_POOLS. +func (l *Libvirt) ConnectNumOfDefinedStoragePools() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(73, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListDefinedStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_STORAGE_POOLS. +func (l *Libvirt) ConnectListDefinedStoragePools(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListDefinedStoragePoolsArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(74, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// ConnectFindStoragePoolSources is the go wrapper for REMOTE_PROC_CONNECT_FIND_STORAGE_POOL_SOURCES. +func (l *Libvirt) ConnectFindStoragePoolSources(Type string, SrcSpec OptString, Flags uint32) (rXML string, err error) { + var buf []byte + + args := ConnectFindStoragePoolSourcesArgs { + Type: Type, + SrcSpec: SrcSpec, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(75, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// StoragePoolCreateXML is the go wrapper for REMOTE_PROC_STORAGE_POOL_CREATE_XML. +func (l *Libvirt) StoragePoolCreateXML(XML string, Flags StoragePoolCreateFlags) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolCreateXMLArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(76, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// StoragePoolDefineXML is the go wrapper for REMOTE_PROC_STORAGE_POOL_DEFINE_XML. +func (l *Libvirt) StoragePoolDefineXML(XML string, Flags uint32) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolDefineXMLArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(77, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// StoragePoolCreate is the go wrapper for REMOTE_PROC_STORAGE_POOL_CREATE. +func (l *Libvirt) StoragePoolCreate(Pool StoragePool, Flags StoragePoolCreateFlags) (err error) { + var buf []byte + + args := StoragePoolCreateArgs { + Pool: Pool, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(78, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolBuild is the go wrapper for REMOTE_PROC_STORAGE_POOL_BUILD. +func (l *Libvirt) StoragePoolBuild(Pool StoragePool, Flags StoragePoolBuildFlags) (err error) { + var buf []byte + + args := StoragePoolBuildArgs { + Pool: Pool, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(79, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolDestroy is the go wrapper for REMOTE_PROC_STORAGE_POOL_DESTROY. +func (l *Libvirt) StoragePoolDestroy(Pool StoragePool) (err error) { + var buf []byte + + args := StoragePoolDestroyArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(80, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolDelete is the go wrapper for REMOTE_PROC_STORAGE_POOL_DELETE. +func (l *Libvirt) StoragePoolDelete(Pool StoragePool, Flags StoragePoolDeleteFlags) (err error) { + var buf []byte + + args := StoragePoolDeleteArgs { + Pool: Pool, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(81, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolUndefine is the go wrapper for REMOTE_PROC_STORAGE_POOL_UNDEFINE. +func (l *Libvirt) StoragePoolUndefine(Pool StoragePool) (err error) { + var buf []byte + + args := StoragePoolUndefineArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(82, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolRefresh is the go wrapper for REMOTE_PROC_STORAGE_POOL_REFRESH. +func (l *Libvirt) StoragePoolRefresh(Pool StoragePool, Flags uint32) (err error) { + var buf []byte + + args := StoragePoolRefreshArgs { + Pool: Pool, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(83, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolLookupByName is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME. +func (l *Libvirt) StoragePoolLookupByName(Name string) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(84, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// StoragePoolLookupByUUID is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID. +func (l *Libvirt) StoragePoolLookupByUUID(UUID UUID) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolLookupByUUIDArgs { + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(85, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// StoragePoolLookupByVolume is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME. +func (l *Libvirt) StoragePoolLookupByVolume(Vol StorageVol) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolLookupByVolumeArgs { + Vol: Vol, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(86, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// StoragePoolGetInfo is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_INFO. +func (l *Libvirt) StoragePoolGetInfo(Pool StoragePool) (rState uint8, rCapacity uint64, rAllocation uint64, rAvailable uint64, err error) { + var buf []byte + + args := StoragePoolGetInfoArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(87, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // State: uint8 + _, err = dec.Decode(&rState) + if err != nil { + return + } + // Capacity: uint64 + _, err = dec.Decode(&rCapacity) + if err != nil { + return + } + // Allocation: uint64 + _, err = dec.Decode(&rAllocation) + if err != nil { + return + } + // Available: uint64 + _, err = dec.Decode(&rAvailable) + if err != nil { + return + } + + return +} + +// StoragePoolGetXMLDesc is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_XML_DESC. +func (l *Libvirt) StoragePoolGetXMLDesc(Pool StoragePool, Flags StorageXMLFlags) (rXML string, err error) { + var buf []byte + + args := StoragePoolGetXMLDescArgs { + Pool: Pool, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(88, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// StoragePoolGetAutostart is the go wrapper for REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART. +func (l *Libvirt) StoragePoolGetAutostart(Pool StoragePool) (rAutostart int32, err error) { + var buf []byte + + args := StoragePoolGetAutostartArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(89, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Autostart: int32 + _, err = dec.Decode(&rAutostart) + if err != nil { + return + } + + return +} + +// StoragePoolSetAutostart is the go wrapper for REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART. +func (l *Libvirt) StoragePoolSetAutostart(Pool StoragePool, Autostart int32) (err error) { + var buf []byte + + args := StoragePoolSetAutostartArgs { + Pool: Pool, + Autostart: Autostart, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(90, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolNumOfVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES. +func (l *Libvirt) StoragePoolNumOfVolumes(Pool StoragePool) (rNum int32, err error) { + var buf []byte + + args := StoragePoolNumOfVolumesArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(91, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// StoragePoolListVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES. +func (l *Libvirt) StoragePoolListVolumes(Pool StoragePool, Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := StoragePoolListVolumesArgs { + Pool: Pool, + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(92, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// StorageVolCreateXML is the go wrapper for REMOTE_PROC_STORAGE_VOL_CREATE_XML. +func (l *Libvirt) StorageVolCreateXML(Pool StoragePool, XML string, Flags StorageVolCreateFlags) (rVol StorageVol, err error) { + var buf []byte + + args := StorageVolCreateXMLArgs { + Pool: Pool, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(93, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vol: StorageVol + _, err = dec.Decode(&rVol) + if err != nil { + return + } + + return +} + +// StorageVolDelete is the go wrapper for REMOTE_PROC_STORAGE_VOL_DELETE. +func (l *Libvirt) StorageVolDelete(Vol StorageVol, Flags StorageVolDeleteFlags) (err error) { + var buf []byte + + args := StorageVolDeleteArgs { + Vol: Vol, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(94, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolLookupByName is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME. +func (l *Libvirt) StorageVolLookupByName(Pool StoragePool, Name string) (rVol StorageVol, err error) { + var buf []byte + + args := StorageVolLookupByNameArgs { + Pool: Pool, + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(95, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vol: StorageVol + _, err = dec.Decode(&rVol) + if err != nil { + return + } + + return +} + +// StorageVolLookupByKey is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY. +func (l *Libvirt) StorageVolLookupByKey(Key string) (rVol StorageVol, err error) { + var buf []byte + + args := StorageVolLookupByKeyArgs { + Key: Key, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(96, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vol: StorageVol + _, err = dec.Decode(&rVol) + if err != nil { + return + } + + return +} + +// StorageVolLookupByPath is the go wrapper for REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH. +func (l *Libvirt) StorageVolLookupByPath(Path string) (rVol StorageVol, err error) { + var buf []byte + + args := StorageVolLookupByPathArgs { + Path: Path, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(97, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vol: StorageVol + _, err = dec.Decode(&rVol) + if err != nil { + return + } + + return +} + +// StorageVolGetInfo is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_INFO. +func (l *Libvirt) StorageVolGetInfo(Vol StorageVol) (rType int8, rCapacity uint64, rAllocation uint64, err error) { + var buf []byte + + args := StorageVolGetInfoArgs { + Vol: Vol, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(98, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: int8 + _, err = dec.Decode(&rType) + if err != nil { + return + } + // Capacity: uint64 + _, err = dec.Decode(&rCapacity) + if err != nil { + return + } + // Allocation: uint64 + _, err = dec.Decode(&rAllocation) + if err != nil { + return + } + + return +} + +// StorageVolGetXMLDesc is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_XML_DESC. +func (l *Libvirt) StorageVolGetXMLDesc(Vol StorageVol, Flags uint32) (rXML string, err error) { + var buf []byte + + args := StorageVolGetXMLDescArgs { + Vol: Vol, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(99, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// StorageVolGetPath is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_PATH. +func (l *Libvirt) StorageVolGetPath(Vol StorageVol) (rName string, err error) { + var buf []byte + + args := StorageVolGetPathArgs { + Vol: Vol, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(100, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Name: string + _, err = dec.Decode(&rName) + if err != nil { + return + } + + return +} + +// NodeGetCellsFreeMemory is the go wrapper for REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY. +func (l *Libvirt) NodeGetCellsFreeMemory(StartCell int32, Maxcells int32) (rCells []uint64, err error) { + var buf []byte + + args := NodeGetCellsFreeMemoryArgs { + StartCell: StartCell, + Maxcells: Maxcells, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(101, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cells: []uint64 + _, err = dec.Decode(&rCells) + if err != nil { + return + } + + return +} + +// NodeGetFreeMemory is the go wrapper for REMOTE_PROC_NODE_GET_FREE_MEMORY. +func (l *Libvirt) NodeGetFreeMemory() (rFreeMem uint64, err error) { + var buf []byte + + var r response + r, err = l.requestStream(102, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // FreeMem: uint64 + _, err = dec.Decode(&rFreeMem) + if err != nil { + return + } + + return +} + +// DomainBlockPeek is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_PEEK. +func (l *Libvirt) DomainBlockPeek(Dom Domain, Path string, Offset uint64, Size uint32, Flags uint32) (rBuffer []byte, err error) { + var buf []byte + + args := DomainBlockPeekArgs { + Dom: Dom, + Path: Path, + Offset: Offset, + Size: Size, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(103, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Buffer: []byte + _, err = dec.Decode(&rBuffer) + if err != nil { + return + } + + return +} + +// DomainMemoryPeek is the go wrapper for REMOTE_PROC_DOMAIN_MEMORY_PEEK. +func (l *Libvirt) DomainMemoryPeek(Dom Domain, Offset uint64, Size uint32, Flags DomainMemoryFlags) (rBuffer []byte, err error) { + var buf []byte + + args := DomainMemoryPeekArgs { + Dom: Dom, + Offset: Offset, + Size: Size, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(104, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Buffer: []byte + _, err = dec.Decode(&rBuffer) + if err != nil { + return + } + + return +} + +// ConnectDomainEventRegister is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER. +func (l *Libvirt) ConnectDomainEventRegister() (rCbRegistered int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(105, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CbRegistered: int32 + _, err = dec.Decode(&rCbRegistered) + if err != nil { + return + } + + return +} + +// ConnectDomainEventDeregister is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER. +func (l *Libvirt) ConnectDomainEventDeregister() (rCbRegistered int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(106, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CbRegistered: int32 + _, err = dec.Decode(&rCbRegistered) + if err != nil { + return + } + + return +} + +// DomainEventLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE. +func (l *Libvirt) DomainEventLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(107, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigratePrepare2 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2. +func (l *Libvirt) DomainMigratePrepare2(UriIn OptString, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookie []byte, rUriOut OptString, err error) { + var buf []byte + + args := DomainMigratePrepare2Args { + UriIn: UriIn, + Flags: Flags, + Dname: Dname, + Resource: Resource, + DomXML: DomXML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(108, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cookie: []byte + _, err = dec.Decode(&rCookie) + if err != nil { + return + } + // UriOut: OptString + _, err = dec.Decode(&rUriOut) + if err != nil { + return + } + + return +} + +// DomainMigrateFinish2 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH2. +func (l *Libvirt) DomainMigrateFinish2(Dname string, Cookie []byte, Uri string, Flags uint64, Retcode int32) (rDdom Domain, err error) { + var buf []byte + + args := DomainMigrateFinish2Args { + Dname: Dname, + Cookie: Cookie, + Uri: Uri, + Flags: Flags, + Retcode: Retcode, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(109, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ddom: Domain + _, err = dec.Decode(&rDdom) + if err != nil { + return + } + + return +} + +// ConnectGetUri is the go wrapper for REMOTE_PROC_CONNECT_GET_URI. +func (l *Libvirt) ConnectGetUri() (rUri string, err error) { + var buf []byte + + var r response + r, err = l.requestStream(110, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Uri: string + _, err = dec.Decode(&rUri) + if err != nil { + return + } + + return +} + +// NodeNumOfDevices is the go wrapper for REMOTE_PROC_NODE_NUM_OF_DEVICES. +func (l *Libvirt) NodeNumOfDevices(Cap OptString, Flags uint32) (rNum int32, err error) { + var buf []byte + + args := NodeNumOfDevicesArgs { + Cap: Cap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(111, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// NodeListDevices is the go wrapper for REMOTE_PROC_NODE_LIST_DEVICES. +func (l *Libvirt) NodeListDevices(Cap OptString, Maxnames int32, Flags uint32) (rNames []string, err error) { + var buf []byte + + args := NodeListDevicesArgs { + Cap: Cap, + Maxnames: Maxnames, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(112, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// NodeDeviceLookupByName is the go wrapper for REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME. +func (l *Libvirt) NodeDeviceLookupByName(Name string) (rDev NodeDevice, err error) { + var buf []byte + + args := NodeDeviceLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(113, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dev: NodeDevice + _, err = dec.Decode(&rDev) + if err != nil { + return + } + + return +} + +// NodeDeviceGetXMLDesc is the go wrapper for REMOTE_PROC_NODE_DEVICE_GET_XML_DESC. +func (l *Libvirt) NodeDeviceGetXMLDesc(Name string, Flags uint32) (rXML string, err error) { + var buf []byte + + args := NodeDeviceGetXMLDescArgs { + Name: Name, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(114, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// NodeDeviceGetParent is the go wrapper for REMOTE_PROC_NODE_DEVICE_GET_PARENT. +func (l *Libvirt) NodeDeviceGetParent(Name string) (rParentName OptString, err error) { + var buf []byte + + args := NodeDeviceGetParentArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(115, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // ParentName: OptString + _, err = dec.Decode(&rParentName) + if err != nil { + return + } + + return +} + +// NodeDeviceNumOfCaps is the go wrapper for REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS. +func (l *Libvirt) NodeDeviceNumOfCaps(Name string) (rNum int32, err error) { + var buf []byte + + args := NodeDeviceNumOfCapsArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(116, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// NodeDeviceListCaps is the go wrapper for REMOTE_PROC_NODE_DEVICE_LIST_CAPS. +func (l *Libvirt) NodeDeviceListCaps(Name string, Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := NodeDeviceListCapsArgs { + Name: Name, + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(117, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// NodeDeviceDettach is the go wrapper for REMOTE_PROC_NODE_DEVICE_DETTACH. +func (l *Libvirt) NodeDeviceDettach(Name string) (err error) { + var buf []byte + + args := NodeDeviceDettachArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(118, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeDeviceReAttach is the go wrapper for REMOTE_PROC_NODE_DEVICE_RE_ATTACH. +func (l *Libvirt) NodeDeviceReAttach(Name string) (err error) { + var buf []byte + + args := NodeDeviceReAttachArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(119, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeDeviceReset is the go wrapper for REMOTE_PROC_NODE_DEVICE_RESET. +func (l *Libvirt) NodeDeviceReset(Name string) (err error) { + var buf []byte + + args := NodeDeviceResetArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(120, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetSecurityLabel is the go wrapper for REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL. +func (l *Libvirt) DomainGetSecurityLabel(Dom Domain) (rLabel []int8, rEnforcing int32, err error) { + var buf []byte + + args := DomainGetSecurityLabelArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(121, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Label: []int8 + _, err = dec.Decode(&rLabel) + if err != nil { + return + } + // Enforcing: int32 + _, err = dec.Decode(&rEnforcing) + if err != nil { + return + } + + return +} + +// NodeGetSecurityModel is the go wrapper for REMOTE_PROC_NODE_GET_SECURITY_MODEL. +func (l *Libvirt) NodeGetSecurityModel() (rModel []int8, rDoi []int8, err error) { + var buf []byte + + var r response + r, err = l.requestStream(122, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Model: []int8 + _, err = dec.Decode(&rModel) + if err != nil { + return + } + // Doi: []int8 + _, err = dec.Decode(&rDoi) + if err != nil { + return + } + + return +} + +// NodeDeviceCreateXML is the go wrapper for REMOTE_PROC_NODE_DEVICE_CREATE_XML. +func (l *Libvirt) NodeDeviceCreateXML(XMLDesc string, Flags uint32) (rDev NodeDevice, err error) { + var buf []byte + + args := NodeDeviceCreateXMLArgs { + XMLDesc: XMLDesc, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(123, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dev: NodeDevice + _, err = dec.Decode(&rDev) + if err != nil { + return + } + + return +} + +// NodeDeviceDestroy is the go wrapper for REMOTE_PROC_NODE_DEVICE_DESTROY. +func (l *Libvirt) NodeDeviceDestroy(Name string) (err error) { + var buf []byte + + args := NodeDeviceDestroyArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(124, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolCreateXMLFrom is the go wrapper for REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM. +func (l *Libvirt) StorageVolCreateXMLFrom(Pool StoragePool, XML string, Clonevol StorageVol, Flags StorageVolCreateFlags) (rVol StorageVol, err error) { + var buf []byte + + args := StorageVolCreateXMLFromArgs { + Pool: Pool, + XML: XML, + Clonevol: Clonevol, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(125, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vol: StorageVol + _, err = dec.Decode(&rVol) + if err != nil { + return + } + + return +} + +// ConnectNumOfInterfaces is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_INTERFACES. +func (l *Libvirt) ConnectNumOfInterfaces() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(126, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_INTERFACES. +func (l *Libvirt) ConnectListInterfaces(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListInterfacesArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(127, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// InterfaceLookupByName is the go wrapper for REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME. +func (l *Libvirt) InterfaceLookupByName(Name string) (rIface Interface, err error) { + var buf []byte + + args := InterfaceLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(128, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Iface: Interface + _, err = dec.Decode(&rIface) + if err != nil { + return + } + + return +} + +// InterfaceLookupByMacString is the go wrapper for REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING. +func (l *Libvirt) InterfaceLookupByMacString(Mac string) (rIface Interface, err error) { + var buf []byte + + args := InterfaceLookupByMacStringArgs { + Mac: Mac, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(129, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Iface: Interface + _, err = dec.Decode(&rIface) + if err != nil { + return + } + + return +} + +// InterfaceGetXMLDesc is the go wrapper for REMOTE_PROC_INTERFACE_GET_XML_DESC. +func (l *Libvirt) InterfaceGetXMLDesc(Iface Interface, Flags uint32) (rXML string, err error) { + var buf []byte + + args := InterfaceGetXMLDescArgs { + Iface: Iface, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(130, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// InterfaceDefineXML is the go wrapper for REMOTE_PROC_INTERFACE_DEFINE_XML. +func (l *Libvirt) InterfaceDefineXML(XML string, Flags uint32) (rIface Interface, err error) { + var buf []byte + + args := InterfaceDefineXMLArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(131, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Iface: Interface + _, err = dec.Decode(&rIface) + if err != nil { + return + } + + return +} + +// InterfaceUndefine is the go wrapper for REMOTE_PROC_INTERFACE_UNDEFINE. +func (l *Libvirt) InterfaceUndefine(Iface Interface) (err error) { + var buf []byte + + args := InterfaceUndefineArgs { + Iface: Iface, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(132, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// InterfaceCreate is the go wrapper for REMOTE_PROC_INTERFACE_CREATE. +func (l *Libvirt) InterfaceCreate(Iface Interface, Flags uint32) (err error) { + var buf []byte + + args := InterfaceCreateArgs { + Iface: Iface, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(133, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// InterfaceDestroy is the go wrapper for REMOTE_PROC_INTERFACE_DESTROY. +func (l *Libvirt) InterfaceDestroy(Iface Interface, Flags uint32) (err error) { + var buf []byte + + args := InterfaceDestroyArgs { + Iface: Iface, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(134, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectDomainXMLFromNative is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_XML_FROM_NATIVE. +func (l *Libvirt) ConnectDomainXMLFromNative(NativeFormat string, NativeConfig string, Flags uint32) (rDomainXML string, err error) { + var buf []byte + + args := ConnectDomainXMLFromNativeArgs { + NativeFormat: NativeFormat, + NativeConfig: NativeConfig, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(135, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // DomainXML: string + _, err = dec.Decode(&rDomainXML) + if err != nil { + return + } + + return +} + +// ConnectDomainXMLToNative is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_XML_TO_NATIVE. +func (l *Libvirt) ConnectDomainXMLToNative(NativeFormat string, DomainXML string, Flags uint32) (rNativeConfig string, err error) { + var buf []byte + + args := ConnectDomainXMLToNativeArgs { + NativeFormat: NativeFormat, + DomainXML: DomainXML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(136, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // NativeConfig: string + _, err = dec.Decode(&rNativeConfig) + if err != nil { + return + } + + return +} + +// ConnectNumOfDefinedInterfaces is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_DEFINED_INTERFACES. +func (l *Libvirt) ConnectNumOfDefinedInterfaces() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(137, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListDefinedInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_DEFINED_INTERFACES. +func (l *Libvirt) ConnectListDefinedInterfaces(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListDefinedInterfacesArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(138, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// ConnectNumOfSecrets is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_SECRETS. +func (l *Libvirt) ConnectNumOfSecrets() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(139, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListSecrets is the go wrapper for REMOTE_PROC_CONNECT_LIST_SECRETS. +func (l *Libvirt) ConnectListSecrets(Maxuuids int32) (rUuids []string, err error) { + var buf []byte + + args := ConnectListSecretsArgs { + Maxuuids: Maxuuids, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(140, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Uuids: []string + _, err = dec.Decode(&rUuids) + if err != nil { + return + } + + return +} + +// SecretLookupByUUID is the go wrapper for REMOTE_PROC_SECRET_LOOKUP_BY_UUID. +func (l *Libvirt) SecretLookupByUUID(UUID UUID) (rOptSecret Secret, err error) { + var buf []byte + + args := SecretLookupByUUIDArgs { + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(141, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptSecret: Secret + _, err = dec.Decode(&rOptSecret) + if err != nil { + return + } + + return +} + +// SecretDefineXML is the go wrapper for REMOTE_PROC_SECRET_DEFINE_XML. +func (l *Libvirt) SecretDefineXML(XML string, Flags uint32) (rOptSecret Secret, err error) { + var buf []byte + + args := SecretDefineXMLArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(142, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptSecret: Secret + _, err = dec.Decode(&rOptSecret) + if err != nil { + return + } + + return +} + +// SecretGetXMLDesc is the go wrapper for REMOTE_PROC_SECRET_GET_XML_DESC. +func (l *Libvirt) SecretGetXMLDesc(OptSecret Secret, Flags uint32) (rXML string, err error) { + var buf []byte + + args := SecretGetXMLDescArgs { + OptSecret: OptSecret, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(143, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// SecretSetValue is the go wrapper for REMOTE_PROC_SECRET_SET_VALUE. +func (l *Libvirt) SecretSetValue(OptSecret Secret, Value []byte, Flags uint32) (err error) { + var buf []byte + + args := SecretSetValueArgs { + OptSecret: OptSecret, + Value: Value, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(144, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// SecretGetValue is the go wrapper for REMOTE_PROC_SECRET_GET_VALUE. +func (l *Libvirt) SecretGetValue(OptSecret Secret, Flags uint32) (rValue []byte, err error) { + var buf []byte + + args := SecretGetValueArgs { + OptSecret: OptSecret, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(145, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Value: []byte + _, err = dec.Decode(&rValue) + if err != nil { + return + } + + return +} + +// SecretUndefine is the go wrapper for REMOTE_PROC_SECRET_UNDEFINE. +func (l *Libvirt) SecretUndefine(OptSecret Secret) (err error) { + var buf []byte + + args := SecretUndefineArgs { + OptSecret: OptSecret, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(146, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// SecretLookupByUsage is the go wrapper for REMOTE_PROC_SECRET_LOOKUP_BY_USAGE. +func (l *Libvirt) SecretLookupByUsage(UsageType int32, UsageID string) (rOptSecret Secret, err error) { + var buf []byte + + args := SecretLookupByUsageArgs { + UsageType: UsageType, + UsageID: UsageID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(147, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptSecret: Secret + _, err = dec.Decode(&rOptSecret) + if err != nil { + return + } + + return +} + +// DomainMigratePrepareTunnel is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL. +func (l *Libvirt) DomainMigratePrepareTunnel(Flags uint64, outStream io.Reader, Dname OptString, Resource uint64, DomXML string) (err error) { + var buf []byte + + args := DomainMigratePrepareTunnelArgs { + Flags: Flags, + Dname: Dname, + Resource: Resource, + DomXML: DomXML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(148, constants.Program, buf, outStream, nil) + if err != nil { + return + } + + return +} + +// ConnectIsSecure is the go wrapper for REMOTE_PROC_CONNECT_IS_SECURE. +func (l *Libvirt) ConnectIsSecure() (rSecure int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(149, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Secure: int32 + _, err = dec.Decode(&rSecure) + if err != nil { + return + } + + return +} + +// DomainIsActive is the go wrapper for REMOTE_PROC_DOMAIN_IS_ACTIVE. +func (l *Libvirt) DomainIsActive(Dom Domain) (rActive int32, err error) { + var buf []byte + + args := DomainIsActiveArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(150, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Active: int32 + _, err = dec.Decode(&rActive) + if err != nil { + return + } + + return +} + +// DomainIsPersistent is the go wrapper for REMOTE_PROC_DOMAIN_IS_PERSISTENT. +func (l *Libvirt) DomainIsPersistent(Dom Domain) (rPersistent int32, err error) { + var buf []byte + + args := DomainIsPersistentArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(151, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Persistent: int32 + _, err = dec.Decode(&rPersistent) + if err != nil { + return + } + + return +} + +// NetworkIsActive is the go wrapper for REMOTE_PROC_NETWORK_IS_ACTIVE. +func (l *Libvirt) NetworkIsActive(Net Network) (rActive int32, err error) { + var buf []byte + + args := NetworkIsActiveArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(152, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Active: int32 + _, err = dec.Decode(&rActive) + if err != nil { + return + } + + return +} + +// NetworkIsPersistent is the go wrapper for REMOTE_PROC_NETWORK_IS_PERSISTENT. +func (l *Libvirt) NetworkIsPersistent(Net Network) (rPersistent int32, err error) { + var buf []byte + + args := NetworkIsPersistentArgs { + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(153, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Persistent: int32 + _, err = dec.Decode(&rPersistent) + if err != nil { + return + } + + return +} + +// StoragePoolIsActive is the go wrapper for REMOTE_PROC_STORAGE_POOL_IS_ACTIVE. +func (l *Libvirt) StoragePoolIsActive(Pool StoragePool) (rActive int32, err error) { + var buf []byte + + args := StoragePoolIsActiveArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(154, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Active: int32 + _, err = dec.Decode(&rActive) + if err != nil { + return + } + + return +} + +// StoragePoolIsPersistent is the go wrapper for REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT. +func (l *Libvirt) StoragePoolIsPersistent(Pool StoragePool) (rPersistent int32, err error) { + var buf []byte + + args := StoragePoolIsPersistentArgs { + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(155, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Persistent: int32 + _, err = dec.Decode(&rPersistent) + if err != nil { + return + } + + return +} + +// InterfaceIsActive is the go wrapper for REMOTE_PROC_INTERFACE_IS_ACTIVE. +func (l *Libvirt) InterfaceIsActive(Iface Interface) (rActive int32, err error) { + var buf []byte + + args := InterfaceIsActiveArgs { + Iface: Iface, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(156, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Active: int32 + _, err = dec.Decode(&rActive) + if err != nil { + return + } + + return +} + +// ConnectGetLibVersion is the go wrapper for REMOTE_PROC_CONNECT_GET_LIB_VERSION. +func (l *Libvirt) ConnectGetLibVersion() (rLibVer uint64, err error) { + var buf []byte + + var r response + r, err = l.requestStream(157, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // LibVer: uint64 + _, err = dec.Decode(&rLibVer) + if err != nil { + return + } + + return +} + +// ConnectCompareCPU is the go wrapper for REMOTE_PROC_CONNECT_COMPARE_CPU. +func (l *Libvirt) ConnectCompareCPU(XML string, Flags ConnectCompareCPUFlags) (rResult int32, err error) { + var buf []byte + + args := ConnectCompareCPUArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(158, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: int32 + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// DomainMemoryStats is the go wrapper for REMOTE_PROC_DOMAIN_MEMORY_STATS. +func (l *Libvirt) DomainMemoryStats(Dom Domain, MaxStats uint32, Flags uint32) (rStats []DomainMemoryStat, err error) { + var buf []byte + + args := DomainMemoryStatsArgs { + Dom: Dom, + MaxStats: MaxStats, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(159, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Stats: []DomainMemoryStat + _, err = dec.Decode(&rStats) + if err != nil { + return + } + + return +} + +// DomainAttachDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS. +func (l *Libvirt) DomainAttachDeviceFlags(Dom Domain, XML string, Flags uint32) (err error) { + var buf []byte + + args := DomainAttachDeviceFlagsArgs { + Dom: Dom, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(160, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainDetachDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS. +func (l *Libvirt) DomainDetachDeviceFlags(Dom Domain, XML string, Flags uint32) (err error) { + var buf []byte + + args := DomainDetachDeviceFlagsArgs { + Dom: Dom, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(161, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectBaselineCPU is the go wrapper for REMOTE_PROC_CONNECT_BASELINE_CPU. +func (l *Libvirt) ConnectBaselineCPU(XMLCPUs []string, Flags ConnectBaselineCPUFlags) (rCPU string, err error) { + var buf []byte + + args := ConnectBaselineCPUArgs { + XMLCPUs: XMLCPUs, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(162, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CPU: string + _, err = dec.Decode(&rCPU) + if err != nil { + return + } + + return +} + +// DomainGetJobInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_JOB_INFO. +func (l *Libvirt) DomainGetJobInfo(Dom Domain) (rType int32, rTimeElapsed uint64, rTimeRemaining uint64, rDataTotal uint64, rDataProcessed uint64, rDataRemaining uint64, rMemTotal uint64, rMemProcessed uint64, rMemRemaining uint64, rFileTotal uint64, rFileProcessed uint64, rFileRemaining uint64, err error) { + var buf []byte + + args := DomainGetJobInfoArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(163, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: int32 + _, err = dec.Decode(&rType) + if err != nil { + return + } + // TimeElapsed: uint64 + _, err = dec.Decode(&rTimeElapsed) + if err != nil { + return + } + // TimeRemaining: uint64 + _, err = dec.Decode(&rTimeRemaining) + if err != nil { + return + } + // DataTotal: uint64 + _, err = dec.Decode(&rDataTotal) + if err != nil { + return + } + // DataProcessed: uint64 + _, err = dec.Decode(&rDataProcessed) + if err != nil { + return + } + // DataRemaining: uint64 + _, err = dec.Decode(&rDataRemaining) + if err != nil { + return + } + // MemTotal: uint64 + _, err = dec.Decode(&rMemTotal) + if err != nil { + return + } + // MemProcessed: uint64 + _, err = dec.Decode(&rMemProcessed) + if err != nil { + return + } + // MemRemaining: uint64 + _, err = dec.Decode(&rMemRemaining) + if err != nil { + return + } + // FileTotal: uint64 + _, err = dec.Decode(&rFileTotal) + if err != nil { + return + } + // FileProcessed: uint64 + _, err = dec.Decode(&rFileProcessed) + if err != nil { + return + } + // FileRemaining: uint64 + _, err = dec.Decode(&rFileRemaining) + if err != nil { + return + } + + return +} + +// DomainAbortJob is the go wrapper for REMOTE_PROC_DOMAIN_ABORT_JOB. +func (l *Libvirt) DomainAbortJob(Dom Domain) (err error) { + var buf []byte + + args := DomainAbortJobArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(164, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolWipe is the go wrapper for REMOTE_PROC_STORAGE_VOL_WIPE. +func (l *Libvirt) StorageVolWipe(Vol StorageVol, Flags uint32) (err error) { + var buf []byte + + args := StorageVolWipeArgs { + Vol: Vol, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(165, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateSetMaxDowntime is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME. +func (l *Libvirt) DomainMigrateSetMaxDowntime(Dom Domain, Downtime uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainMigrateSetMaxDowntimeArgs { + Dom: Dom, + Downtime: Downtime, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(166, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectDomainEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY. +func (l *Libvirt) ConnectDomainEventRegisterAny(EventID int32) (err error) { + var buf []byte + + args := ConnectDomainEventRegisterAnyArgs { + EventID: EventID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(167, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectDomainEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY. +func (l *Libvirt) ConnectDomainEventDeregisterAny(EventID int32) (err error) { + var buf []byte + + args := ConnectDomainEventDeregisterAnyArgs { + EventID: EventID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(168, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventReboot is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_REBOOT. +func (l *Libvirt) DomainEventReboot() (err error) { + var buf []byte + + + _, err = l.requestStream(169, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventRtcChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE. +func (l *Libvirt) DomainEventRtcChange() (err error) { + var buf []byte + + + _, err = l.requestStream(170, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventWatchdog is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_WATCHDOG. +func (l *Libvirt) DomainEventWatchdog() (err error) { + var buf []byte + + + _, err = l.requestStream(171, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventIOError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_IO_ERROR. +func (l *Libvirt) DomainEventIOError() (err error) { + var buf []byte + + + _, err = l.requestStream(172, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventGraphics is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_GRAPHICS. +func (l *Libvirt) DomainEventGraphics() (err error) { + var buf []byte + + + _, err = l.requestStream(173, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainUpdateDeviceFlags is the go wrapper for REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS. +func (l *Libvirt) DomainUpdateDeviceFlags(Dom Domain, XML string, Flags DomainDeviceModifyFlags) (err error) { + var buf []byte + + args := DomainUpdateDeviceFlagsArgs { + Dom: Dom, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(174, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NwfilterLookupByName is the go wrapper for REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME. +func (l *Libvirt) NwfilterLookupByName(Name string) (rOptNwfilter Nwfilter, err error) { + var buf []byte + + args := NwfilterLookupByNameArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(175, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptNwfilter: Nwfilter + _, err = dec.Decode(&rOptNwfilter) + if err != nil { + return + } + + return +} + +// NwfilterLookupByUUID is the go wrapper for REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID. +func (l *Libvirt) NwfilterLookupByUUID(UUID UUID) (rOptNwfilter Nwfilter, err error) { + var buf []byte + + args := NwfilterLookupByUUIDArgs { + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(176, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptNwfilter: Nwfilter + _, err = dec.Decode(&rOptNwfilter) + if err != nil { + return + } + + return +} + +// NwfilterGetXMLDesc is the go wrapper for REMOTE_PROC_NWFILTER_GET_XML_DESC. +func (l *Libvirt) NwfilterGetXMLDesc(OptNwfilter Nwfilter, Flags uint32) (rXML string, err error) { + var buf []byte + + args := NwfilterGetXMLDescArgs { + OptNwfilter: OptNwfilter, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(177, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// ConnectNumOfNwfilters is the go wrapper for REMOTE_PROC_CONNECT_NUM_OF_NWFILTERS. +func (l *Libvirt) ConnectNumOfNwfilters() (rNum int32, err error) { + var buf []byte + + var r response + r, err = l.requestStream(178, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// ConnectListNwfilters is the go wrapper for REMOTE_PROC_CONNECT_LIST_NWFILTERS. +func (l *Libvirt) ConnectListNwfilters(Maxnames int32) (rNames []string, err error) { + var buf []byte + + args := ConnectListNwfiltersArgs { + Maxnames: Maxnames, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(179, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// NwfilterDefineXML is the go wrapper for REMOTE_PROC_NWFILTER_DEFINE_XML. +func (l *Libvirt) NwfilterDefineXML(XML string) (rOptNwfilter Nwfilter, err error) { + var buf []byte + + args := NwfilterDefineXMLArgs { + XML: XML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(180, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptNwfilter: Nwfilter + _, err = dec.Decode(&rOptNwfilter) + if err != nil { + return + } + + return +} + +// NwfilterUndefine is the go wrapper for REMOTE_PROC_NWFILTER_UNDEFINE. +func (l *Libvirt) NwfilterUndefine(OptNwfilter Nwfilter) (err error) { + var buf []byte + + args := NwfilterUndefineArgs { + OptNwfilter: OptNwfilter, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(181, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainManagedSave is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE. +func (l *Libvirt) DomainManagedSave(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainManagedSaveArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(182, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainHasManagedSaveImage is the go wrapper for REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE. +func (l *Libvirt) DomainHasManagedSaveImage(Dom Domain, Flags uint32) (rResult int32, err error) { + var buf []byte + + args := DomainHasManagedSaveImageArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(183, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: int32 + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// DomainManagedSaveRemove is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE. +func (l *Libvirt) DomainManagedSaveRemove(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainManagedSaveRemoveArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(184, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSnapshotCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML. +func (l *Libvirt) DomainSnapshotCreateXML(Dom Domain, XMLDesc string, Flags uint32) (rSnap DomainSnapshot, err error) { + var buf []byte + + args := DomainSnapshotCreateXMLArgs { + Dom: Dom, + XMLDesc: XMLDesc, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(185, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snap: DomainSnapshot + _, err = dec.Decode(&rSnap) + if err != nil { + return + } + + return +} + +// DomainSnapshotGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_GET_XML_DESC. +func (l *Libvirt) DomainSnapshotGetXMLDesc(Snap DomainSnapshot, Flags uint32) (rXML string, err error) { + var buf []byte + + args := DomainSnapshotGetXMLDescArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(186, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainSnapshotNum is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_NUM. +func (l *Libvirt) DomainSnapshotNum(Dom Domain, Flags uint32) (rNum int32, err error) { + var buf []byte + + args := DomainSnapshotNumArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(187, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainSnapshotListNames is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES. +func (l *Libvirt) DomainSnapshotListNames(Dom Domain, Maxnames int32, Flags uint32) (rNames []string, err error) { + var buf []byte + + args := DomainSnapshotListNamesArgs { + Dom: Dom, + Maxnames: Maxnames, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(188, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// DomainSnapshotLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME. +func (l *Libvirt) DomainSnapshotLookupByName(Dom Domain, Name string, Flags uint32) (rSnap DomainSnapshot, err error) { + var buf []byte + + args := DomainSnapshotLookupByNameArgs { + Dom: Dom, + Name: Name, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(189, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snap: DomainSnapshot + _, err = dec.Decode(&rSnap) + if err != nil { + return + } + + return +} + +// DomainHasCurrentSnapshot is the go wrapper for REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT. +func (l *Libvirt) DomainHasCurrentSnapshot(Dom Domain, Flags uint32) (rResult int32, err error) { + var buf []byte + + args := DomainHasCurrentSnapshotArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(190, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: int32 + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// DomainSnapshotCurrent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT. +func (l *Libvirt) DomainSnapshotCurrent(Dom Domain, Flags uint32) (rSnap DomainSnapshot, err error) { + var buf []byte + + args := DomainSnapshotCurrentArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(191, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snap: DomainSnapshot + _, err = dec.Decode(&rSnap) + if err != nil { + return + } + + return +} + +// DomainRevertToSnapshot is the go wrapper for REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT. +func (l *Libvirt) DomainRevertToSnapshot(Snap DomainSnapshot, Flags uint32) (err error) { + var buf []byte + + args := DomainRevertToSnapshotArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(192, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSnapshotDelete is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE. +func (l *Libvirt) DomainSnapshotDelete(Snap DomainSnapshot, Flags DomainSnapshotDeleteFlags) (err error) { + var buf []byte + + args := DomainSnapshotDeleteArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(193, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetBlockInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_INFO. +func (l *Libvirt) DomainGetBlockInfo(Dom Domain, Path string, Flags uint32) (rAllocation uint64, rCapacity uint64, rPhysical uint64, err error) { + var buf []byte + + args := DomainGetBlockInfoArgs { + Dom: Dom, + Path: Path, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(194, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Allocation: uint64 + _, err = dec.Decode(&rAllocation) + if err != nil { + return + } + // Capacity: uint64 + _, err = dec.Decode(&rCapacity) + if err != nil { + return + } + // Physical: uint64 + _, err = dec.Decode(&rPhysical) + if err != nil { + return + } + + return +} + +// DomainEventIOErrorReason is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON. +func (l *Libvirt) DomainEventIOErrorReason() (err error) { + var buf []byte + + + _, err = l.requestStream(195, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCreateWithFlags is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_WITH_FLAGS. +func (l *Libvirt) DomainCreateWithFlags(Dom Domain, Flags uint32) (rDom Domain, err error) { + var buf []byte + + args := DomainCreateWithFlagsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(196, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainSetMemoryParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_PARAMETERS. +func (l *Libvirt) DomainSetMemoryParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetMemoryParametersArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(197, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetMemoryParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS. +func (l *Libvirt) DomainGetMemoryParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetMemoryParametersArgs { + Dom: Dom, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(198, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainSetVcpusFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS. +func (l *Libvirt) DomainSetVcpusFlags(Dom Domain, Nvcpus uint32, Flags uint32) (err error) { + var buf []byte + + args := DomainSetVcpusFlagsArgs { + Dom: Dom, + Nvcpus: Nvcpus, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(199, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetVcpusFlags is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS. +func (l *Libvirt) DomainGetVcpusFlags(Dom Domain, Flags uint32) (rNum int32, err error) { + var buf []byte + + args := DomainGetVcpusFlagsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(200, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainOpenConsole is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_CONSOLE. +func (l *Libvirt) DomainOpenConsole(Dom Domain, DevName OptString, inStream io.Writer, Flags uint32) (err error) { + var buf []byte + + args := DomainOpenConsoleArgs { + Dom: Dom, + DevName: DevName, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(201, constants.Program, buf, nil, inStream) + if err != nil { + return + } + + return +} + +// DomainIsUpdated is the go wrapper for REMOTE_PROC_DOMAIN_IS_UPDATED. +func (l *Libvirt) DomainIsUpdated(Dom Domain) (rUpdated int32, err error) { + var buf []byte + + args := DomainIsUpdatedArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(202, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Updated: int32 + _, err = dec.Decode(&rUpdated) + if err != nil { + return + } + + return +} + +// ConnectGetSysinfo is the go wrapper for REMOTE_PROC_CONNECT_GET_SYSINFO. +func (l *Libvirt) ConnectGetSysinfo(Flags uint32) (rSysinfo string, err error) { + var buf []byte + + args := ConnectGetSysinfoArgs { + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(203, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Sysinfo: string + _, err = dec.Decode(&rSysinfo) + if err != nil { + return + } + + return +} + +// DomainSetMemoryFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS. +func (l *Libvirt) DomainSetMemoryFlags(Dom Domain, Memory uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainSetMemoryFlagsArgs { + Dom: Dom, + Memory: Memory, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(204, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetBlkioParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLKIO_PARAMETERS. +func (l *Libvirt) DomainSetBlkioParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetBlkioParametersArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(205, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetBlkioParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS. +func (l *Libvirt) DomainGetBlkioParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetBlkioParametersArgs { + Dom: Dom, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(206, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainMigrateSetMaxSpeed is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED. +func (l *Libvirt) DomainMigrateSetMaxSpeed(Dom Domain, Bandwidth uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainMigrateSetMaxSpeedArgs { + Dom: Dom, + Bandwidth: Bandwidth, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(207, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolUpload is the go wrapper for REMOTE_PROC_STORAGE_VOL_UPLOAD. +func (l *Libvirt) StorageVolUpload(Vol StorageVol, outStream io.Reader, Offset uint64, Length uint64, Flags StorageVolUploadFlags) (err error) { + var buf []byte + + args := StorageVolUploadArgs { + Vol: Vol, + Offset: Offset, + Length: Length, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(208, constants.Program, buf, outStream, nil) + if err != nil { + return + } + + return +} + +// StorageVolDownload is the go wrapper for REMOTE_PROC_STORAGE_VOL_DOWNLOAD. +func (l *Libvirt) StorageVolDownload(Vol StorageVol, inStream io.Writer, Offset uint64, Length uint64, Flags StorageVolDownloadFlags) (err error) { + var buf []byte + + args := StorageVolDownloadArgs { + Vol: Vol, + Offset: Offset, + Length: Length, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(209, constants.Program, buf, nil, inStream) + if err != nil { + return + } + + return +} + +// DomainInjectNmi is the go wrapper for REMOTE_PROC_DOMAIN_INJECT_NMI. +func (l *Libvirt) DomainInjectNmi(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainInjectNmiArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(210, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainScreenshot is the go wrapper for REMOTE_PROC_DOMAIN_SCREENSHOT. +func (l *Libvirt) DomainScreenshot(Dom Domain, inStream io.Writer, Screen uint32, Flags uint32) (rMime OptString, err error) { + var buf []byte + + args := DomainScreenshotArgs { + Dom: Dom, + Screen: Screen, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(211, constants.Program, buf, nil, inStream) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Mime: OptString + _, err = dec.Decode(&rMime) + if err != nil { + return + } + + return +} + +// DomainGetState is the go wrapper for REMOTE_PROC_DOMAIN_GET_STATE. +func (l *Libvirt) DomainGetState(Dom Domain, Flags uint32) (rState int32, rReason int32, err error) { + var buf []byte + + args := DomainGetStateArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(212, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // State: int32 + _, err = dec.Decode(&rState) + if err != nil { + return + } + // Reason: int32 + _, err = dec.Decode(&rReason) + if err != nil { + return + } + + return +} + +// DomainMigrateBegin3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3. +func (l *Libvirt) DomainMigrateBegin3(Dom Domain, Xmlin OptString, Flags uint64, Dname OptString, Resource uint64) (rCookieOut []byte, rXML string, err error) { + var buf []byte + + args := DomainMigrateBegin3Args { + Dom: Dom, + Xmlin: Xmlin, + Flags: Flags, + Dname: Dname, + Resource: Resource, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(213, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainMigratePrepare3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3. +func (l *Libvirt) DomainMigratePrepare3(CookieIn []byte, UriIn OptString, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookieOut []byte, rUriOut OptString, err error) { + var buf []byte + + args := DomainMigratePrepare3Args { + CookieIn: CookieIn, + UriIn: UriIn, + Flags: Flags, + Dname: Dname, + Resource: Resource, + DomXML: DomXML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(214, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + // UriOut: OptString + _, err = dec.Decode(&rUriOut) + if err != nil { + return + } + + return +} + +// DomainMigratePrepareTunnel3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3. +func (l *Libvirt) DomainMigratePrepareTunnel3(CookieIn []byte, outStream io.Reader, Flags uint64, Dname OptString, Resource uint64, DomXML string) (rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigratePrepareTunnel3Args { + CookieIn: CookieIn, + Flags: Flags, + Dname: Dname, + Resource: Resource, + DomXML: DomXML, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(215, constants.Program, buf, outStream, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigratePerform3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3. +func (l *Libvirt) DomainMigratePerform3(Dom Domain, Xmlin OptString, CookieIn []byte, Dconnuri OptString, Uri OptString, Flags uint64, Dname OptString, Resource uint64) (rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigratePerform3Args { + Dom: Dom, + Xmlin: Xmlin, + CookieIn: CookieIn, + Dconnuri: Dconnuri, + Uri: Uri, + Flags: Flags, + Dname: Dname, + Resource: Resource, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(216, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigrateFinish3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH3. +func (l *Libvirt) DomainMigrateFinish3(Dname string, CookieIn []byte, Dconnuri OptString, Uri OptString, Flags uint64, Cancelled int32) (rDom Domain, rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigrateFinish3Args { + Dname: Dname, + CookieIn: CookieIn, + Dconnuri: Dconnuri, + Uri: Uri, + Flags: Flags, + Cancelled: Cancelled, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(217, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigrateConfirm3 is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3. +func (l *Libvirt) DomainMigrateConfirm3(Dom Domain, CookieIn []byte, Flags uint64, Cancelled int32) (err error) { + var buf []byte + + args := DomainMigrateConfirm3Args { + Dom: Dom, + CookieIn: CookieIn, + Flags: Flags, + Cancelled: Cancelled, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(218, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetSchedulerParametersFlags is the go wrapper for REMOTE_PROC_DOMAIN_SET_SCHEDULER_PARAMETERS_FLAGS. +func (l *Libvirt) DomainSetSchedulerParametersFlags(Dom Domain, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetSchedulerParametersFlagsArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(219, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// InterfaceChangeBegin is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_BEGIN. +func (l *Libvirt) InterfaceChangeBegin(Flags uint32) (err error) { + var buf []byte + + args := InterfaceChangeBeginArgs { + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(220, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// InterfaceChangeCommit is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_COMMIT. +func (l *Libvirt) InterfaceChangeCommit(Flags uint32) (err error) { + var buf []byte + + args := InterfaceChangeCommitArgs { + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(221, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// InterfaceChangeRollback is the go wrapper for REMOTE_PROC_INTERFACE_CHANGE_ROLLBACK. +func (l *Libvirt) InterfaceChangeRollback(Flags uint32) (err error) { + var buf []byte + + args := InterfaceChangeRollbackArgs { + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(222, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetSchedulerParametersFlags is the go wrapper for REMOTE_PROC_DOMAIN_GET_SCHEDULER_PARAMETERS_FLAGS. +func (l *Libvirt) DomainGetSchedulerParametersFlags(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetSchedulerParametersFlagsArgs { + Dom: Dom, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(223, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// DomainEventControlError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR. +func (l *Libvirt) DomainEventControlError() (err error) { + var buf []byte + + + _, err = l.requestStream(224, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainPinVcpuFlags is the go wrapper for REMOTE_PROC_DOMAIN_PIN_VCPU_FLAGS. +func (l *Libvirt) DomainPinVcpuFlags(Dom Domain, Vcpu uint32, Cpumap []byte, Flags uint32) (err error) { + var buf []byte + + args := DomainPinVcpuFlagsArgs { + Dom: Dom, + Vcpu: Vcpu, + Cpumap: Cpumap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(225, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSendKey is the go wrapper for REMOTE_PROC_DOMAIN_SEND_KEY. +func (l *Libvirt) DomainSendKey(Dom Domain, Codeset uint32, Holdtime uint32, Keycodes []uint32, Flags uint32) (err error) { + var buf []byte + + args := DomainSendKeyArgs { + Dom: Dom, + Codeset: Codeset, + Holdtime: Holdtime, + Keycodes: Keycodes, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(226, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeGetCPUStats is the go wrapper for REMOTE_PROC_NODE_GET_CPU_STATS. +func (l *Libvirt) NodeGetCPUStats(CPUNum int32, Nparams int32, Flags uint32) (rParams []NodeGetCPUStats, rNparams int32, err error) { + var buf []byte + + args := NodeGetCPUStatsArgs { + CPUNum: CPUNum, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(227, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []NodeGetCPUStats + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// NodeGetMemoryStats is the go wrapper for REMOTE_PROC_NODE_GET_MEMORY_STATS. +func (l *Libvirt) NodeGetMemoryStats(Nparams int32, CellNum int32, Flags uint32) (rParams []NodeGetMemoryStats, rNparams int32, err error) { + var buf []byte + + args := NodeGetMemoryStatsArgs { + Nparams: Nparams, + CellNum: CellNum, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(228, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []NodeGetMemoryStats + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainGetControlInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_CONTROL_INFO. +func (l *Libvirt) DomainGetControlInfo(Dom Domain, Flags uint32) (rState uint32, rDetails uint32, rStateTime uint64, err error) { + var buf []byte + + args := DomainGetControlInfoArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(229, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // State: uint32 + _, err = dec.Decode(&rState) + if err != nil { + return + } + // Details: uint32 + _, err = dec.Decode(&rDetails) + if err != nil { + return + } + // StateTime: uint64 + _, err = dec.Decode(&rStateTime) + if err != nil { + return + } + + return +} + +// DomainGetVcpuPinInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_VCPU_PIN_INFO. +func (l *Libvirt) DomainGetVcpuPinInfo(Dom Domain, Ncpumaps int32, Maplen int32, Flags uint32) (rCpumaps []byte, rNum int32, err error) { + var buf []byte + + args := DomainGetVcpuPinInfoArgs { + Dom: Dom, + Ncpumaps: Ncpumaps, + Maplen: Maplen, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(230, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cpumaps: []byte + _, err = dec.Decode(&rCpumaps) + if err != nil { + return + } + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainUndefineFlags is the go wrapper for REMOTE_PROC_DOMAIN_UNDEFINE_FLAGS. +func (l *Libvirt) DomainUndefineFlags(Dom Domain, Flags DomainUndefineFlagsValues) (err error) { + var buf []byte + + args := DomainUndefineFlagsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(231, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSaveFlags is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_FLAGS. +func (l *Libvirt) DomainSaveFlags(Dom Domain, To string, Dxml OptString, Flags uint32) (err error) { + var buf []byte + + args := DomainSaveFlagsArgs { + Dom: Dom, + To: To, + Dxml: Dxml, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(232, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainRestoreFlags is the go wrapper for REMOTE_PROC_DOMAIN_RESTORE_FLAGS. +func (l *Libvirt) DomainRestoreFlags(From string, Dxml OptString, Flags uint32) (err error) { + var buf []byte + + args := DomainRestoreFlagsArgs { + From: From, + Dxml: Dxml, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(233, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainDestroyFlags is the go wrapper for REMOTE_PROC_DOMAIN_DESTROY_FLAGS. +func (l *Libvirt) DomainDestroyFlags(Dom Domain, Flags DomainDestroyFlagsValues) (err error) { + var buf []byte + + args := DomainDestroyFlagsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(234, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSaveImageGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_IMAGE_GET_XML_DESC. +func (l *Libvirt) DomainSaveImageGetXMLDesc(File string, Flags uint32) (rXML string, err error) { + var buf []byte + + args := DomainSaveImageGetXMLDescArgs { + File: File, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(235, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainSaveImageDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_SAVE_IMAGE_DEFINE_XML. +func (l *Libvirt) DomainSaveImageDefineXML(File string, Dxml string, Flags uint32) (err error) { + var buf []byte + + args := DomainSaveImageDefineXMLArgs { + File: File, + Dxml: Dxml, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(236, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainBlockJobAbort is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_JOB_ABORT. +func (l *Libvirt) DomainBlockJobAbort(Dom Domain, Path string, Flags DomainBlockJobAbortFlags) (err error) { + var buf []byte + + args := DomainBlockJobAbortArgs { + Dom: Dom, + Path: Path, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(237, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetBlockJobInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_JOB_INFO. +func (l *Libvirt) DomainGetBlockJobInfo(Dom Domain, Path string, Flags uint32) (rFound int32, rType int32, rBandwidth uint64, rCur uint64, rEnd uint64, err error) { + var buf []byte + + args := DomainGetBlockJobInfoArgs { + Dom: Dom, + Path: Path, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(238, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Found: int32 + _, err = dec.Decode(&rFound) + if err != nil { + return + } + // Type: int32 + _, err = dec.Decode(&rType) + if err != nil { + return + } + // Bandwidth: uint64 + _, err = dec.Decode(&rBandwidth) + if err != nil { + return + } + // Cur: uint64 + _, err = dec.Decode(&rCur) + if err != nil { + return + } + // End: uint64 + _, err = dec.Decode(&rEnd) + if err != nil { + return + } + + return +} + +// DomainBlockJobSetSpeed is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_JOB_SET_SPEED. +func (l *Libvirt) DomainBlockJobSetSpeed(Dom Domain, Path string, Bandwidth uint64, Flags DomainBlockJobSetSpeedFlags) (err error) { + var buf []byte + + args := DomainBlockJobSetSpeedArgs { + Dom: Dom, + Path: Path, + Bandwidth: Bandwidth, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(239, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainBlockPull is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_PULL. +func (l *Libvirt) DomainBlockPull(Dom Domain, Path string, Bandwidth uint64, Flags DomainBlockPullFlags) (err error) { + var buf []byte + + args := DomainBlockPullArgs { + Dom: Dom, + Path: Path, + Bandwidth: Bandwidth, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(240, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventBlockJob is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB. +func (l *Libvirt) DomainEventBlockJob() (err error) { + var buf []byte + + + _, err = l.requestStream(241, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateGetMaxSpeed is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_SPEED. +func (l *Libvirt) DomainMigrateGetMaxSpeed(Dom Domain, Flags uint32) (rBandwidth uint64, err error) { + var buf []byte + + args := DomainMigrateGetMaxSpeedArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(242, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Bandwidth: uint64 + _, err = dec.Decode(&rBandwidth) + if err != nil { + return + } + + return +} + +// DomainBlockStatsFlags is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_STATS_FLAGS. +func (l *Libvirt) DomainBlockStatsFlags(Dom Domain, Path string, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainBlockStatsFlagsArgs { + Dom: Dom, + Path: Path, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(243, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainSnapshotGetParent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_GET_PARENT. +func (l *Libvirt) DomainSnapshotGetParent(Snap DomainSnapshot, Flags uint32) (rSnap DomainSnapshot, err error) { + var buf []byte + + args := DomainSnapshotGetParentArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(244, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snap: DomainSnapshot + _, err = dec.Decode(&rSnap) + if err != nil { + return + } + + return +} + +// DomainReset is the go wrapper for REMOTE_PROC_DOMAIN_RESET. +func (l *Libvirt) DomainReset(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainResetArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(245, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSnapshotNumChildren is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_NUM_CHILDREN. +func (l *Libvirt) DomainSnapshotNumChildren(Snap DomainSnapshot, Flags uint32) (rNum int32, err error) { + var buf []byte + + args := DomainSnapshotNumChildrenArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(246, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Num: int32 + _, err = dec.Decode(&rNum) + if err != nil { + return + } + + return +} + +// DomainSnapshotListChildrenNames is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_CHILDREN_NAMES. +func (l *Libvirt) DomainSnapshotListChildrenNames(Snap DomainSnapshot, Maxnames int32, Flags uint32) (rNames []string, err error) { + var buf []byte + + args := DomainSnapshotListChildrenNamesArgs { + Snap: Snap, + Maxnames: Maxnames, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(247, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Names: []string + _, err = dec.Decode(&rNames) + if err != nil { + return + } + + return +} + +// DomainEventDiskChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE. +func (l *Libvirt) DomainEventDiskChange() (err error) { + var buf []byte + + + _, err = l.requestStream(248, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainOpenGraphics is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_GRAPHICS. +func (l *Libvirt) DomainOpenGraphics(Dom Domain, Idx uint32, Flags DomainOpenGraphicsFlags) (err error) { + var buf []byte + + args := DomainOpenGraphicsArgs { + Dom: Dom, + Idx: Idx, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(249, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeSuspendForDuration is the go wrapper for REMOTE_PROC_NODE_SUSPEND_FOR_DURATION. +func (l *Libvirt) NodeSuspendForDuration(Target uint32, Duration uint64, Flags uint32) (err error) { + var buf []byte + + args := NodeSuspendForDurationArgs { + Target: Target, + Duration: Duration, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(250, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainBlockResize is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_RESIZE. +func (l *Libvirt) DomainBlockResize(Dom Domain, Disk string, Size uint64, Flags DomainBlockResizeFlags) (err error) { + var buf []byte + + args := DomainBlockResizeArgs { + Dom: Dom, + Disk: Disk, + Size: Size, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(251, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetBlockIOTune is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE. +func (l *Libvirt) DomainSetBlockIOTune(Dom Domain, Disk string, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetBlockIOTuneArgs { + Dom: Dom, + Disk: Disk, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(252, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetBlockIOTune is the go wrapper for REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE. +func (l *Libvirt) DomainGetBlockIOTune(Dom Domain, Disk OptString, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetBlockIOTuneArgs { + Dom: Dom, + Disk: Disk, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(253, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainSetNumaParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_NUMA_PARAMETERS. +func (l *Libvirt) DomainSetNumaParameters(Dom Domain, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetNumaParametersArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(254, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetNumaParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_NUMA_PARAMETERS. +func (l *Libvirt) DomainGetNumaParameters(Dom Domain, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetNumaParametersArgs { + Dom: Dom, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(255, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainSetInterfaceParameters is the go wrapper for REMOTE_PROC_DOMAIN_SET_INTERFACE_PARAMETERS. +func (l *Libvirt) DomainSetInterfaceParameters(Dom Domain, Device string, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetInterfaceParametersArgs { + Dom: Dom, + Device: Device, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(256, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetInterfaceParameters is the go wrapper for REMOTE_PROC_DOMAIN_GET_INTERFACE_PARAMETERS. +func (l *Libvirt) DomainGetInterfaceParameters(Dom Domain, Device string, Nparams int32, Flags DomainModificationImpact) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetInterfaceParametersArgs { + Dom: Dom, + Device: Device, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(257, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainShutdownFlags is the go wrapper for REMOTE_PROC_DOMAIN_SHUTDOWN_FLAGS. +func (l *Libvirt) DomainShutdownFlags(Dom Domain, Flags DomainShutdownFlagValues) (err error) { + var buf []byte + + args := DomainShutdownFlagsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(258, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolWipePattern is the go wrapper for REMOTE_PROC_STORAGE_VOL_WIPE_PATTERN. +func (l *Libvirt) StorageVolWipePattern(Vol StorageVol, Algorithm uint32, Flags uint32) (err error) { + var buf []byte + + args := StorageVolWipePatternArgs { + Vol: Vol, + Algorithm: Algorithm, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(259, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolResize is the go wrapper for REMOTE_PROC_STORAGE_VOL_RESIZE. +func (l *Libvirt) StorageVolResize(Vol StorageVol, Capacity uint64, Flags StorageVolResizeFlags) (err error) { + var buf []byte + + args := StorageVolResizeArgs { + Vol: Vol, + Capacity: Capacity, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(260, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainPmSuspendForDuration is the go wrapper for REMOTE_PROC_DOMAIN_PM_SUSPEND_FOR_DURATION. +func (l *Libvirt) DomainPmSuspendForDuration(Dom Domain, Target uint32, Duration uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainPmSuspendForDurationArgs { + Dom: Dom, + Target: Target, + Duration: Duration, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(261, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetCPUStats is the go wrapper for REMOTE_PROC_DOMAIN_GET_CPU_STATS. +func (l *Libvirt) DomainGetCPUStats(Dom Domain, Nparams uint32, StartCPU int32, Ncpus uint32, Flags TypedParameterFlags) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := DomainGetCPUStatsArgs { + Dom: Dom, + Nparams: Nparams, + StartCPU: StartCPU, + Ncpus: Ncpus, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(262, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainGetDiskErrors is the go wrapper for REMOTE_PROC_DOMAIN_GET_DISK_ERRORS. +func (l *Libvirt) DomainGetDiskErrors(Dom Domain, Maxerrors uint32, Flags uint32) (rErrors []DomainDiskError, rNerrors int32, err error) { + var buf []byte + + args := DomainGetDiskErrorsArgs { + Dom: Dom, + Maxerrors: Maxerrors, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(263, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Errors: []DomainDiskError + _, err = dec.Decode(&rErrors) + if err != nil { + return + } + // Nerrors: int32 + _, err = dec.Decode(&rNerrors) + if err != nil { + return + } + + return +} + +// DomainSetMetadata is the go wrapper for REMOTE_PROC_DOMAIN_SET_METADATA. +func (l *Libvirt) DomainSetMetadata(Dom Domain, Type int32, Metadata OptString, Key OptString, Uri OptString, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainSetMetadataArgs { + Dom: Dom, + Type: Type, + Metadata: Metadata, + Key: Key, + Uri: Uri, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(264, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetMetadata is the go wrapper for REMOTE_PROC_DOMAIN_GET_METADATA. +func (l *Libvirt) DomainGetMetadata(Dom Domain, Type int32, Uri OptString, Flags DomainModificationImpact) (rMetadata string, err error) { + var buf []byte + + args := DomainGetMetadataArgs { + Dom: Dom, + Type: Type, + Uri: Uri, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(265, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Metadata: string + _, err = dec.Decode(&rMetadata) + if err != nil { + return + } + + return +} + +// DomainBlockRebase is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_REBASE. +func (l *Libvirt) DomainBlockRebase(Dom Domain, Path string, Base OptString, Bandwidth uint64, Flags DomainBlockRebaseFlags) (err error) { + var buf []byte + + args := DomainBlockRebaseArgs { + Dom: Dom, + Path: Path, + Base: Base, + Bandwidth: Bandwidth, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(266, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainPmWakeup is the go wrapper for REMOTE_PROC_DOMAIN_PM_WAKEUP. +func (l *Libvirt) DomainPmWakeup(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainPmWakeupArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(267, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventTrayChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE. +func (l *Libvirt) DomainEventTrayChange() (err error) { + var buf []byte + + + _, err = l.requestStream(268, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventPmwakeup is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP. +func (l *Libvirt) DomainEventPmwakeup() (err error) { + var buf []byte + + + _, err = l.requestStream(269, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventPmsuspend is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND. +func (l *Libvirt) DomainEventPmsuspend() (err error) { + var buf []byte + + + _, err = l.requestStream(270, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSnapshotIsCurrent is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_IS_CURRENT. +func (l *Libvirt) DomainSnapshotIsCurrent(Snap DomainSnapshot, Flags uint32) (rCurrent int32, err error) { + var buf []byte + + args := DomainSnapshotIsCurrentArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(271, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Current: int32 + _, err = dec.Decode(&rCurrent) + if err != nil { + return + } + + return +} + +// DomainSnapshotHasMetadata is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_HAS_METADATA. +func (l *Libvirt) DomainSnapshotHasMetadata(Snap DomainSnapshot, Flags uint32) (rMetadata int32, err error) { + var buf []byte + + args := DomainSnapshotHasMetadataArgs { + Snap: Snap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(272, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Metadata: int32 + _, err = dec.Decode(&rMetadata) + if err != nil { + return + } + + return +} + +// ConnectListAllDomains is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS. +func (l *Libvirt) ConnectListAllDomains(NeedResults int32, Flags ConnectListAllDomainsFlags) (rDomains []Domain, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllDomainsArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(273, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Domains: []Domain + _, err = dec.Decode(&rDomains) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainListAllSnapshots is the go wrapper for REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS. +func (l *Libvirt) DomainListAllSnapshots(Dom Domain, NeedResults int32, Flags uint32) (rSnapshots []DomainSnapshot, rRet int32, err error) { + var buf []byte + + args := DomainListAllSnapshotsArgs { + Dom: Dom, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(274, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snapshots: []DomainSnapshot + _, err = dec.Decode(&rSnapshots) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainSnapshotListAllChildren is the go wrapper for REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_ALL_CHILDREN. +func (l *Libvirt) DomainSnapshotListAllChildren(Snapshot DomainSnapshot, NeedResults int32, Flags uint32) (rSnapshots []DomainSnapshot, rRet int32, err error) { + var buf []byte + + args := DomainSnapshotListAllChildrenArgs { + Snapshot: Snapshot, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(275, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Snapshots: []DomainSnapshot + _, err = dec.Decode(&rSnapshots) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainEventBalloonChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE. +func (l *Libvirt) DomainEventBalloonChange() (err error) { + var buf []byte + + + _, err = l.requestStream(276, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetHostname is the go wrapper for REMOTE_PROC_DOMAIN_GET_HOSTNAME. +func (l *Libvirt) DomainGetHostname(Dom Domain, Flags uint32) (rHostname string, err error) { + var buf []byte + + args := DomainGetHostnameArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(277, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Hostname: string + _, err = dec.Decode(&rHostname) + if err != nil { + return + } + + return +} + +// DomainGetSecurityLabelList is the go wrapper for REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL_LIST. +func (l *Libvirt) DomainGetSecurityLabelList(Dom Domain) (rLabels []DomainGetSecurityLabelRet, rRet int32, err error) { + var buf []byte + + args := DomainGetSecurityLabelListArgs { + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(278, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Labels: []DomainGetSecurityLabelRet + _, err = dec.Decode(&rLabels) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainPinEmulator is the go wrapper for REMOTE_PROC_DOMAIN_PIN_EMULATOR. +func (l *Libvirt) DomainPinEmulator(Dom Domain, Cpumap []byte, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainPinEmulatorArgs { + Dom: Dom, + Cpumap: Cpumap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(279, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetEmulatorPinInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_EMULATOR_PIN_INFO. +func (l *Libvirt) DomainGetEmulatorPinInfo(Dom Domain, Maplen int32, Flags DomainModificationImpact) (rCpumaps []byte, rRet int32, err error) { + var buf []byte + + args := DomainGetEmulatorPinInfoArgs { + Dom: Dom, + Maplen: Maplen, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(280, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cpumaps: []byte + _, err = dec.Decode(&rCpumaps) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllStoragePools is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS. +func (l *Libvirt) ConnectListAllStoragePools(NeedResults int32, Flags ConnectListAllStoragePoolsFlags) (rPools []StoragePool, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllStoragePoolsArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(281, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pools: []StoragePool + _, err = dec.Decode(&rPools) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// StoragePoolListAllVolumes is the go wrapper for REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES. +func (l *Libvirt) StoragePoolListAllVolumes(Pool StoragePool, NeedResults int32, Flags uint32) (rVols []StorageVol, rRet uint32, err error) { + var buf []byte + + args := StoragePoolListAllVolumesArgs { + Pool: Pool, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(282, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Vols: []StorageVol + _, err = dec.Decode(&rVols) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllNetworks is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS. +func (l *Libvirt) ConnectListAllNetworks(NeedResults int32, Flags ConnectListAllNetworksFlags) (rNets []Network, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllNetworksArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(283, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Nets: []Network + _, err = dec.Decode(&rNets) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllInterfaces is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES. +func (l *Libvirt) ConnectListAllInterfaces(NeedResults int32, Flags ConnectListAllInterfacesFlags) (rIfaces []Interface, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllInterfacesArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(284, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ifaces: []Interface + _, err = dec.Decode(&rIfaces) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllNodeDevices is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES. +func (l *Libvirt) ConnectListAllNodeDevices(NeedResults int32, Flags uint32) (rDevices []NodeDevice, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllNodeDevicesArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(285, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Devices: []NodeDevice + _, err = dec.Decode(&rDevices) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllNwfilters is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS. +func (l *Libvirt) ConnectListAllNwfilters(NeedResults int32, Flags uint32) (rFilters []Nwfilter, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllNwfiltersArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(286, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Filters: []Nwfilter + _, err = dec.Decode(&rFilters) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectListAllSecrets is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_SECRETS. +func (l *Libvirt) ConnectListAllSecrets(NeedResults int32, Flags ConnectListAllSecretsFlags) (rSecrets []Secret, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllSecretsArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(287, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Secrets: []Secret + _, err = dec.Decode(&rSecrets) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// NodeSetMemoryParameters is the go wrapper for REMOTE_PROC_NODE_SET_MEMORY_PARAMETERS. +func (l *Libvirt) NodeSetMemoryParameters(Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := NodeSetMemoryParametersArgs { + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(288, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeGetMemoryParameters is the go wrapper for REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS. +func (l *Libvirt) NodeGetMemoryParameters(Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := NodeGetMemoryParametersArgs { + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(289, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainBlockCommit is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_COMMIT. +func (l *Libvirt) DomainBlockCommit(Dom Domain, Disk string, Base OptString, Top OptString, Bandwidth uint64, Flags DomainBlockCommitFlags) (err error) { + var buf []byte + + args := DomainBlockCommitArgs { + Dom: Dom, + Disk: Disk, + Base: Base, + Top: Top, + Bandwidth: Bandwidth, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(290, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkUpdate is the go wrapper for REMOTE_PROC_NETWORK_UPDATE. +func (l *Libvirt) NetworkUpdate(Net Network, Command uint32, Section uint32, ParentIndex int32, XML string, Flags NetworkUpdateFlags) (err error) { + var buf []byte + + args := NetworkUpdateArgs { + Net: Net, + Command: Command, + Section: Section, + ParentIndex: ParentIndex, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(291, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventPmsuspendDisk is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK. +func (l *Libvirt) DomainEventPmsuspendDisk() (err error) { + var buf []byte + + + _, err = l.requestStream(292, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeGetCPUMap is the go wrapper for REMOTE_PROC_NODE_GET_CPU_MAP. +func (l *Libvirt) NodeGetCPUMap(NeedMap int32, NeedOnline int32, Flags uint32) (rCpumap []byte, rOnline uint32, rRet int32, err error) { + var buf []byte + + args := NodeGetCPUMapArgs { + NeedMap: NeedMap, + NeedOnline: NeedOnline, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(293, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Cpumap: []byte + _, err = dec.Decode(&rCpumap) + if err != nil { + return + } + // Online: uint32 + _, err = dec.Decode(&rOnline) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainFstrim is the go wrapper for REMOTE_PROC_DOMAIN_FSTRIM. +func (l *Libvirt) DomainFstrim(Dom Domain, MountPoint OptString, Minimum uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainFstrimArgs { + Dom: Dom, + MountPoint: MountPoint, + Minimum: Minimum, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(294, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSendProcessSignal is the go wrapper for REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL. +func (l *Libvirt) DomainSendProcessSignal(Dom Domain, PidValue int64, Signum uint32, Flags uint32) (err error) { + var buf []byte + + args := DomainSendProcessSignalArgs { + Dom: Dom, + PidValue: PidValue, + Signum: Signum, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(295, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainOpenChannel is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_CHANNEL. +func (l *Libvirt) DomainOpenChannel(Dom Domain, Name OptString, inStream io.Writer, Flags DomainChannelFlags) (err error) { + var buf []byte + + args := DomainOpenChannelArgs { + Dom: Dom, + Name: Name, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(296, constants.Program, buf, nil, inStream) + if err != nil { + return + } + + return +} + +// NodeDeviceLookupScsiHostByWwn is the go wrapper for REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN. +func (l *Libvirt) NodeDeviceLookupScsiHostByWwn(Wwnn string, Wwpn string, Flags uint32) (rDev NodeDevice, err error) { + var buf []byte + + args := NodeDeviceLookupScsiHostByWwnArgs { + Wwnn: Wwnn, + Wwpn: Wwpn, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(297, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dev: NodeDevice + _, err = dec.Decode(&rDev) + if err != nil { + return + } + + return +} + +// DomainGetJobStats is the go wrapper for REMOTE_PROC_DOMAIN_GET_JOB_STATS. +func (l *Libvirt) DomainGetJobStats(Dom Domain, Flags DomainGetJobStatsFlags) (rType int32, rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetJobStatsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(298, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: int32 + _, err = dec.Decode(&rType) + if err != nil { + return + } + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// DomainMigrateGetCompressionCache is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE. +func (l *Libvirt) DomainMigrateGetCompressionCache(Dom Domain, Flags uint32) (rCacheSize uint64, err error) { + var buf []byte + + args := DomainMigrateGetCompressionCacheArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(299, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CacheSize: uint64 + _, err = dec.Decode(&rCacheSize) + if err != nil { + return + } + + return +} + +// DomainMigrateSetCompressionCache is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE. +func (l *Libvirt) DomainMigrateSetCompressionCache(Dom Domain, CacheSize uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainMigrateSetCompressionCacheArgs { + Dom: Dom, + CacheSize: CacheSize, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(300, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeDeviceDetachFlags is the go wrapper for REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS. +func (l *Libvirt) NodeDeviceDetachFlags(Name string, DriverName OptString, Flags uint32) (err error) { + var buf []byte + + args := NodeDeviceDetachFlagsArgs { + Name: Name, + DriverName: DriverName, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(301, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateBegin3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3_PARAMS. +func (l *Libvirt) DomainMigrateBegin3Params(Dom Domain, Params []TypedParam, Flags uint32) (rCookieOut []byte, rXML string, err error) { + var buf []byte + + args := DomainMigrateBegin3ParamsArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(302, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainMigratePrepare3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3_PARAMS. +func (l *Libvirt) DomainMigratePrepare3Params(Params []TypedParam, CookieIn []byte, Flags uint32) (rCookieOut []byte, rUriOut OptString, err error) { + var buf []byte + + args := DomainMigratePrepare3ParamsArgs { + Params: Params, + CookieIn: CookieIn, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(303, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + // UriOut: OptString + _, err = dec.Decode(&rUriOut) + if err != nil { + return + } + + return +} + +// DomainMigratePrepareTunnel3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3_PARAMS. +func (l *Libvirt) DomainMigratePrepareTunnel3Params(Params []TypedParam, CookieIn []byte, Flags uint32) (rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigratePrepareTunnel3ParamsArgs { + Params: Params, + CookieIn: CookieIn, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(304, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigratePerform3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3_PARAMS. +func (l *Libvirt) DomainMigratePerform3Params(Dom Domain, Dconnuri OptString, Params []TypedParam, CookieIn []byte, Flags DomainMigrateFlags) (rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigratePerform3ParamsArgs { + Dom: Dom, + Dconnuri: Dconnuri, + Params: Params, + CookieIn: CookieIn, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(305, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigrateFinish3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_FINISH3_PARAMS. +func (l *Libvirt) DomainMigrateFinish3Params(Params []TypedParam, CookieIn []byte, Flags uint32, Cancelled int32) (rDom Domain, rCookieOut []byte, err error) { + var buf []byte + + args := DomainMigrateFinish3ParamsArgs { + Params: Params, + CookieIn: CookieIn, + Flags: Flags, + Cancelled: Cancelled, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(306, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + // CookieOut: []byte + _, err = dec.Decode(&rCookieOut) + if err != nil { + return + } + + return +} + +// DomainMigrateConfirm3Params is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3_PARAMS. +func (l *Libvirt) DomainMigrateConfirm3Params(Dom Domain, Params []TypedParam, CookieIn []byte, Flags uint32, Cancelled int32) (err error) { + var buf []byte + + args := DomainMigrateConfirm3ParamsArgs { + Dom: Dom, + Params: Params, + CookieIn: CookieIn, + Flags: Flags, + Cancelled: Cancelled, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(307, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetMemoryStatsPeriod is the go wrapper for REMOTE_PROC_DOMAIN_SET_MEMORY_STATS_PERIOD. +func (l *Libvirt) DomainSetMemoryStatsPeriod(Dom Domain, Period int32, Flags DomainMemoryModFlags) (err error) { + var buf []byte + + args := DomainSetMemoryStatsPeriodArgs { + Dom: Dom, + Period: Period, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(308, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCreateXMLWithFiles is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_XML_WITH_FILES. +func (l *Libvirt) DomainCreateXMLWithFiles(XMLDesc string, Flags DomainCreateFlags) (rDom Domain, err error) { + var buf []byte + + args := DomainCreateXMLWithFilesArgs { + XMLDesc: XMLDesc, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(309, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainCreateWithFiles is the go wrapper for REMOTE_PROC_DOMAIN_CREATE_WITH_FILES. +func (l *Libvirt) DomainCreateWithFiles(Dom Domain, Flags DomainCreateFlags) (rDom Domain, err error) { + var buf []byte + + args := DomainCreateWithFilesArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(310, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainEventDeviceRemoved is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED. +func (l *Libvirt) DomainEventDeviceRemoved() (err error) { + var buf []byte + + + _, err = l.requestStream(311, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectGetCPUModelNames is the go wrapper for REMOTE_PROC_CONNECT_GET_CPU_MODEL_NAMES. +func (l *Libvirt) ConnectGetCPUModelNames(Arch string, NeedResults int32, Flags uint32) (rModels []string, rRet int32, err error) { + var buf []byte + + args := ConnectGetCPUModelNamesArgs { + Arch: Arch, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(312, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Models: []string + _, err = dec.Decode(&rModels) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectNetworkEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY. +func (l *Libvirt) ConnectNetworkEventRegisterAny(EventID int32, Net OptNetwork) (rCallbackID int32, err error) { + var buf []byte + + args := ConnectNetworkEventRegisterAnyArgs { + EventID: EventID, + Net: Net, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(313, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// ConnectNetworkEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY. +func (l *Libvirt) ConnectNetworkEventDeregisterAny(CallbackID int32) (err error) { + var buf []byte + + args := ConnectNetworkEventDeregisterAnyArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(314, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkEventLifecycle is the go wrapper for REMOTE_PROC_NETWORK_EVENT_LIFECYCLE. +func (l *Libvirt) NetworkEventLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(315, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectDomainEventCallbackRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY. +func (l *Libvirt) ConnectDomainEventCallbackRegisterAny(EventID int32, Dom OptDomain) (rCallbackID int32, err error) { + var buf []byte + + args := ConnectDomainEventCallbackRegisterAnyArgs { + EventID: EventID, + Dom: Dom, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(316, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// ConnectDomainEventCallbackDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY. +func (l *Libvirt) ConnectDomainEventCallbackDeregisterAny(CallbackID int32) (err error) { + var buf []byte + + args := ConnectDomainEventCallbackDeregisterAnyArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(317, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE. +func (l *Libvirt) DomainEventCallbackLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(318, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackReboot is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT. +func (l *Libvirt) DomainEventCallbackReboot() (err error) { + var buf []byte + + + _, err = l.requestStream(319, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackRtcChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE. +func (l *Libvirt) DomainEventCallbackRtcChange() (err error) { + var buf []byte + + + _, err = l.requestStream(320, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackWatchdog is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG. +func (l *Libvirt) DomainEventCallbackWatchdog() (err error) { + var buf []byte + + + _, err = l.requestStream(321, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackIOError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR. +func (l *Libvirt) DomainEventCallbackIOError() (err error) { + var buf []byte + + + _, err = l.requestStream(322, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackGraphics is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS. +func (l *Libvirt) DomainEventCallbackGraphics() (err error) { + var buf []byte + + + _, err = l.requestStream(323, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackIOErrorReason is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON. +func (l *Libvirt) DomainEventCallbackIOErrorReason() (err error) { + var buf []byte + + + _, err = l.requestStream(324, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackControlError is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR. +func (l *Libvirt) DomainEventCallbackControlError() (err error) { + var buf []byte + + + _, err = l.requestStream(325, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackBlockJob is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB. +func (l *Libvirt) DomainEventCallbackBlockJob() (err error) { + var buf []byte + + + _, err = l.requestStream(326, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackDiskChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE. +func (l *Libvirt) DomainEventCallbackDiskChange() (err error) { + var buf []byte + + + _, err = l.requestStream(327, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackTrayChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE. +func (l *Libvirt) DomainEventCallbackTrayChange() (err error) { + var buf []byte + + + _, err = l.requestStream(328, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackPmwakeup is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP. +func (l *Libvirt) DomainEventCallbackPmwakeup() (err error) { + var buf []byte + + + _, err = l.requestStream(329, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackPmsuspend is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND. +func (l *Libvirt) DomainEventCallbackPmsuspend() (err error) { + var buf []byte + + + _, err = l.requestStream(330, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackBalloonChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE. +func (l *Libvirt) DomainEventCallbackBalloonChange() (err error) { + var buf []byte + + + _, err = l.requestStream(331, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackPmsuspendDisk is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK. +func (l *Libvirt) DomainEventCallbackPmsuspendDisk() (err error) { + var buf []byte + + + _, err = l.requestStream(332, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackDeviceRemoved is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED. +func (l *Libvirt) DomainEventCallbackDeviceRemoved() (err error) { + var buf []byte + + + _, err = l.requestStream(333, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCoreDumpWithFormat is the go wrapper for REMOTE_PROC_DOMAIN_CORE_DUMP_WITH_FORMAT. +func (l *Libvirt) DomainCoreDumpWithFormat(Dom Domain, To string, Dumpformat uint32, Flags DomainCoreDumpFlags) (err error) { + var buf []byte + + args := DomainCoreDumpWithFormatArgs { + Dom: Dom, + To: To, + Dumpformat: Dumpformat, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(334, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainFsfreeze is the go wrapper for REMOTE_PROC_DOMAIN_FSFREEZE. +func (l *Libvirt) DomainFsfreeze(Dom Domain, Mountpoints []string, Flags uint32) (rFilesystems int32, err error) { + var buf []byte + + args := DomainFsfreezeArgs { + Dom: Dom, + Mountpoints: Mountpoints, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(335, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Filesystems: int32 + _, err = dec.Decode(&rFilesystems) + if err != nil { + return + } + + return +} + +// DomainFsthaw is the go wrapper for REMOTE_PROC_DOMAIN_FSTHAW. +func (l *Libvirt) DomainFsthaw(Dom Domain, Mountpoints []string, Flags uint32) (rFilesystems int32, err error) { + var buf []byte + + args := DomainFsthawArgs { + Dom: Dom, + Mountpoints: Mountpoints, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(336, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Filesystems: int32 + _, err = dec.Decode(&rFilesystems) + if err != nil { + return + } + + return +} + +// DomainGetTime is the go wrapper for REMOTE_PROC_DOMAIN_GET_TIME. +func (l *Libvirt) DomainGetTime(Dom Domain, Flags uint32) (rSeconds int64, rNseconds uint32, err error) { + var buf []byte + + args := DomainGetTimeArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(337, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Seconds: int64 + _, err = dec.Decode(&rSeconds) + if err != nil { + return + } + // Nseconds: uint32 + _, err = dec.Decode(&rNseconds) + if err != nil { + return + } + + return +} + +// DomainSetTime is the go wrapper for REMOTE_PROC_DOMAIN_SET_TIME. +func (l *Libvirt) DomainSetTime(Dom Domain, Seconds int64, Nseconds uint32, Flags DomainSetTimeFlags) (err error) { + var buf []byte + + args := DomainSetTimeArgs { + Dom: Dom, + Seconds: Seconds, + Nseconds: Nseconds, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(338, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventBlockJob2 is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB_2. +func (l *Libvirt) DomainEventBlockJob2() (err error) { + var buf []byte + + + _, err = l.requestStream(339, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeGetFreePages is the go wrapper for REMOTE_PROC_NODE_GET_FREE_PAGES. +func (l *Libvirt) NodeGetFreePages(Pages []uint32, StartCell int32, CellCount uint32, Flags uint32) (rCounts []uint64, err error) { + var buf []byte + + args := NodeGetFreePagesArgs { + Pages: Pages, + StartCell: StartCell, + CellCount: CellCount, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(340, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Counts: []uint64 + _, err = dec.Decode(&rCounts) + if err != nil { + return + } + + return +} + +// NetworkGetDhcpLeases is the go wrapper for REMOTE_PROC_NETWORK_GET_DHCP_LEASES. +func (l *Libvirt) NetworkGetDhcpLeases(Net Network, Mac OptString, NeedResults int32, Flags uint32) (rLeases []NetworkDhcpLease, rRet uint32, err error) { + var buf []byte + + args := NetworkGetDhcpLeasesArgs { + Net: Net, + Mac: Mac, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(341, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Leases: []NetworkDhcpLease + _, err = dec.Decode(&rLeases) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// ConnectGetDomainCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_DOMAIN_CAPABILITIES. +func (l *Libvirt) ConnectGetDomainCapabilities(Emulatorbin OptString, Arch OptString, Machine OptString, Virttype OptString, Flags uint32) (rCapabilities string, err error) { + var buf []byte + + args := ConnectGetDomainCapabilitiesArgs { + Emulatorbin: Emulatorbin, + Arch: Arch, + Machine: Machine, + Virttype: Virttype, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(342, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Capabilities: string + _, err = dec.Decode(&rCapabilities) + if err != nil { + return + } + + return +} + +// DomainOpenGraphicsFd is the go wrapper for REMOTE_PROC_DOMAIN_OPEN_GRAPHICS_FD. +func (l *Libvirt) DomainOpenGraphicsFd(Dom Domain, Idx uint32, Flags DomainOpenGraphicsFlags) (err error) { + var buf []byte + + args := DomainOpenGraphicsFdArgs { + Dom: Dom, + Idx: Idx, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(343, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectGetAllDomainStats is the go wrapper for REMOTE_PROC_CONNECT_GET_ALL_DOMAIN_STATS. +func (l *Libvirt) ConnectGetAllDomainStats(Doms []Domain, Stats uint32, Flags ConnectGetAllDomainStatsFlags) (rRetStats []DomainStatsRecord, err error) { + var buf []byte + + args := ConnectGetAllDomainStatsArgs { + Doms: Doms, + Stats: Stats, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(344, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // RetStats: []DomainStatsRecord + _, err = dec.Decode(&rRetStats) + if err != nil { + return + } + + return +} + +// DomainBlockCopy is the go wrapper for REMOTE_PROC_DOMAIN_BLOCK_COPY. +func (l *Libvirt) DomainBlockCopy(Dom Domain, Path string, Destxml string, Params []TypedParam, Flags DomainBlockCopyFlags) (err error) { + var buf []byte + + args := DomainBlockCopyArgs { + Dom: Dom, + Path: Path, + Destxml: Destxml, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(345, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackTunable is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TUNABLE. +func (l *Libvirt) DomainEventCallbackTunable() (err error) { + var buf []byte + + + _, err = l.requestStream(346, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeAllocPages is the go wrapper for REMOTE_PROC_NODE_ALLOC_PAGES. +func (l *Libvirt) NodeAllocPages(PageSizes []uint32, PageCounts []uint64, StartCell int32, CellCount uint32, Flags NodeAllocPagesFlags) (rRet int32, err error) { + var buf []byte + + args := NodeAllocPagesArgs { + PageSizes: PageSizes, + PageCounts: PageCounts, + StartCell: StartCell, + CellCount: CellCount, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(347, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainEventCallbackAgentLifecycle is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_AGENT_LIFECYCLE. +func (l *Libvirt) DomainEventCallbackAgentLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(348, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetFsinfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_FSINFO. +func (l *Libvirt) DomainGetFsinfo(Dom Domain, Flags uint32) (rInfo []DomainFsinfo, rRet uint32, err error) { + var buf []byte + + args := DomainGetFsinfoArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(349, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Info: []DomainFsinfo + _, err = dec.Decode(&rInfo) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainDefineXMLFlags is the go wrapper for REMOTE_PROC_DOMAIN_DEFINE_XML_FLAGS. +func (l *Libvirt) DomainDefineXMLFlags(XML string, Flags DomainDefineFlags) (rDom Domain, err error) { + var buf []byte + + args := DomainDefineXMLFlagsArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(350, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Dom: Domain + _, err = dec.Decode(&rDom) + if err != nil { + return + } + + return +} + +// DomainGetIothreadInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_IOTHREAD_INFO. +func (l *Libvirt) DomainGetIothreadInfo(Dom Domain, Flags DomainModificationImpact) (rInfo []DomainIothreadInfo, rRet uint32, err error) { + var buf []byte + + args := DomainGetIothreadInfoArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(351, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Info: []DomainIothreadInfo + _, err = dec.Decode(&rInfo) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainPinIothread is the go wrapper for REMOTE_PROC_DOMAIN_PIN_IOTHREAD. +func (l *Libvirt) DomainPinIothread(Dom Domain, IothreadsID uint32, Cpumap []byte, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainPinIothreadArgs { + Dom: Dom, + IothreadsID: IothreadsID, + Cpumap: Cpumap, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(352, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainInterfaceAddresses is the go wrapper for REMOTE_PROC_DOMAIN_INTERFACE_ADDRESSES. +func (l *Libvirt) DomainInterfaceAddresses(Dom Domain, Source uint32, Flags uint32) (rIfaces []DomainInterface, err error) { + var buf []byte + + args := DomainInterfaceAddressesArgs { + Dom: Dom, + Source: Source, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(353, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ifaces: []DomainInterface + _, err = dec.Decode(&rIfaces) + if err != nil { + return + } + + return +} + +// DomainEventCallbackDeviceAdded is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_ADDED. +func (l *Libvirt) DomainEventCallbackDeviceAdded() (err error) { + var buf []byte + + + _, err = l.requestStream(354, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainAddIothread is the go wrapper for REMOTE_PROC_DOMAIN_ADD_IOTHREAD. +func (l *Libvirt) DomainAddIothread(Dom Domain, IothreadID uint32, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainAddIothreadArgs { + Dom: Dom, + IothreadID: IothreadID, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(355, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainDelIothread is the go wrapper for REMOTE_PROC_DOMAIN_DEL_IOTHREAD. +func (l *Libvirt) DomainDelIothread(Dom Domain, IothreadID uint32, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainDelIothreadArgs { + Dom: Dom, + IothreadID: IothreadID, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(356, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetUserPassword is the go wrapper for REMOTE_PROC_DOMAIN_SET_USER_PASSWORD. +func (l *Libvirt) DomainSetUserPassword(Dom Domain, User OptString, Password OptString, Flags DomainSetUserPasswordFlags) (err error) { + var buf []byte + + args := DomainSetUserPasswordArgs { + Dom: Dom, + User: User, + Password: Password, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(357, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainRename is the go wrapper for REMOTE_PROC_DOMAIN_RENAME. +func (l *Libvirt) DomainRename(Dom Domain, NewName OptString, Flags uint32) (rRetcode int32, err error) { + var buf []byte + + args := DomainRenameArgs { + Dom: Dom, + NewName: NewName, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(358, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Retcode: int32 + _, err = dec.Decode(&rRetcode) + if err != nil { + return + } + + return +} + +// DomainEventCallbackMigrationIteration is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION. +func (l *Libvirt) DomainEventCallbackMigrationIteration() (err error) { + var buf []byte + + + _, err = l.requestStream(359, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectRegisterCloseCallback is the go wrapper for REMOTE_PROC_CONNECT_REGISTER_CLOSE_CALLBACK. +func (l *Libvirt) ConnectRegisterCloseCallback() (err error) { + var buf []byte + + + _, err = l.requestStream(360, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectUnregisterCloseCallback is the go wrapper for REMOTE_PROC_CONNECT_UNREGISTER_CLOSE_CALLBACK. +func (l *Libvirt) ConnectUnregisterCloseCallback() (err error) { + var buf []byte + + + _, err = l.requestStream(361, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectEventConnectionClosed is the go wrapper for REMOTE_PROC_CONNECT_EVENT_CONNECTION_CLOSED. +func (l *Libvirt) ConnectEventConnectionClosed() (err error) { + var buf []byte + + + _, err = l.requestStream(362, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackJobCompleted is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_JOB_COMPLETED. +func (l *Libvirt) DomainEventCallbackJobCompleted() (err error) { + var buf []byte + + + _, err = l.requestStream(363, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateStartPostCopy is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_START_POST_COPY. +func (l *Libvirt) DomainMigrateStartPostCopy(Dom Domain, Flags uint32) (err error) { + var buf []byte + + args := DomainMigrateStartPostCopyArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(364, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetPerfEvents is the go wrapper for REMOTE_PROC_DOMAIN_GET_PERF_EVENTS. +func (l *Libvirt) DomainGetPerfEvents(Dom Domain, Flags DomainModificationImpact) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetPerfEventsArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(365, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// DomainSetPerfEvents is the go wrapper for REMOTE_PROC_DOMAIN_SET_PERF_EVENTS. +func (l *Libvirt) DomainSetPerfEvents(Dom Domain, Params []TypedParam, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainSetPerfEventsArgs { + Dom: Dom, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(366, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventCallbackDeviceRemovalFailed is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVAL_FAILED. +func (l *Libvirt) DomainEventCallbackDeviceRemovalFailed() (err error) { + var buf []byte + + + _, err = l.requestStream(367, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectStoragePoolEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_REGISTER_ANY. +func (l *Libvirt) ConnectStoragePoolEventRegisterAny(EventID int32, Pool OptStoragePool) (rCallbackID int32, err error) { + var buf []byte + + args := ConnectStoragePoolEventRegisterAnyArgs { + EventID: EventID, + Pool: Pool, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(368, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// ConnectStoragePoolEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_DEREGISTER_ANY. +func (l *Libvirt) ConnectStoragePoolEventDeregisterAny(CallbackID int32) (err error) { + var buf []byte + + args := ConnectStoragePoolEventDeregisterAnyArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(369, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolEventLifecycle is the go wrapper for REMOTE_PROC_STORAGE_POOL_EVENT_LIFECYCLE. +func (l *Libvirt) StoragePoolEventLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(370, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetGuestVcpus is the go wrapper for REMOTE_PROC_DOMAIN_GET_GUEST_VCPUS. +func (l *Libvirt) DomainGetGuestVcpus(Dom Domain, Flags uint32) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetGuestVcpusArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(371, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// DomainSetGuestVcpus is the go wrapper for REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS. +func (l *Libvirt) DomainSetGuestVcpus(Dom Domain, Cpumap string, State int32, Flags uint32) (err error) { + var buf []byte + + args := DomainSetGuestVcpusArgs { + Dom: Dom, + Cpumap: Cpumap, + State: State, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(372, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolEventRefresh is the go wrapper for REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH. +func (l *Libvirt) StoragePoolEventRefresh() (err error) { + var buf []byte + + + _, err = l.requestStream(373, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectNodeDeviceEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_REGISTER_ANY. +func (l *Libvirt) ConnectNodeDeviceEventRegisterAny(EventID int32, Dev OptNodeDevice) (rCallbackID int32, err error) { + var buf []byte + + args := ConnectNodeDeviceEventRegisterAnyArgs { + EventID: EventID, + Dev: Dev, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(374, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// ConnectNodeDeviceEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_DEREGISTER_ANY. +func (l *Libvirt) ConnectNodeDeviceEventDeregisterAny(CallbackID int32) (err error) { + var buf []byte + + args := ConnectNodeDeviceEventDeregisterAnyArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(375, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeDeviceEventLifecycle is the go wrapper for REMOTE_PROC_NODE_DEVICE_EVENT_LIFECYCLE. +func (l *Libvirt) NodeDeviceEventLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(376, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NodeDeviceEventUpdate is the go wrapper for REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE. +func (l *Libvirt) NodeDeviceEventUpdate() (err error) { + var buf []byte + + + _, err = l.requestStream(377, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StorageVolGetInfoFlags is the go wrapper for REMOTE_PROC_STORAGE_VOL_GET_INFO_FLAGS. +func (l *Libvirt) StorageVolGetInfoFlags(Vol StorageVol, Flags uint32) (rType int8, rCapacity uint64, rAllocation uint64, err error) { + var buf []byte + + args := StorageVolGetInfoFlagsArgs { + Vol: Vol, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(378, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Type: int8 + _, err = dec.Decode(&rType) + if err != nil { + return + } + // Capacity: uint64 + _, err = dec.Decode(&rCapacity) + if err != nil { + return + } + // Allocation: uint64 + _, err = dec.Decode(&rAllocation) + if err != nil { + return + } + + return +} + +// DomainEventCallbackMetadataChange is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_CALLBACK_METADATA_CHANGE. +func (l *Libvirt) DomainEventCallbackMetadataChange() (err error) { + var buf []byte + + + _, err = l.requestStream(379, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectSecretEventRegisterAny is the go wrapper for REMOTE_PROC_CONNECT_SECRET_EVENT_REGISTER_ANY. +func (l *Libvirt) ConnectSecretEventRegisterAny(EventID int32, OptSecret OptSecret) (rCallbackID int32, err error) { + var buf []byte + + args := ConnectSecretEventRegisterAnyArgs { + EventID: EventID, + OptSecret: OptSecret, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(380, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CallbackID: int32 + _, err = dec.Decode(&rCallbackID) + if err != nil { + return + } + + return +} + +// ConnectSecretEventDeregisterAny is the go wrapper for REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY. +func (l *Libvirt) ConnectSecretEventDeregisterAny(CallbackID int32) (err error) { + var buf []byte + + args := ConnectSecretEventDeregisterAnyArgs { + CallbackID: CallbackID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(381, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// SecretEventLifecycle is the go wrapper for REMOTE_PROC_SECRET_EVENT_LIFECYCLE. +func (l *Libvirt) SecretEventLifecycle() (err error) { + var buf []byte + + + _, err = l.requestStream(382, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// SecretEventValueChanged is the go wrapper for REMOTE_PROC_SECRET_EVENT_VALUE_CHANGED. +func (l *Libvirt) SecretEventValueChanged() (err error) { + var buf []byte + + + _, err = l.requestStream(383, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetVcpu is the go wrapper for REMOTE_PROC_DOMAIN_SET_VCPU. +func (l *Libvirt) DomainSetVcpu(Dom Domain, Cpumap string, State int32, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainSetVcpuArgs { + Dom: Dom, + Cpumap: Cpumap, + State: State, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(384, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainEventBlockThreshold is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_BLOCK_THRESHOLD. +func (l *Libvirt) DomainEventBlockThreshold() (err error) { + var buf []byte + + + _, err = l.requestStream(385, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetBlockThreshold is the go wrapper for REMOTE_PROC_DOMAIN_SET_BLOCK_THRESHOLD. +func (l *Libvirt) DomainSetBlockThreshold(Dom Domain, Dev string, Threshold uint64, Flags uint32) (err error) { + var buf []byte + + args := DomainSetBlockThresholdArgs { + Dom: Dom, + Dev: Dev, + Threshold: Threshold, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(386, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainMigrateGetMaxDowntime is the go wrapper for REMOTE_PROC_DOMAIN_MIGRATE_GET_MAX_DOWNTIME. +func (l *Libvirt) DomainMigrateGetMaxDowntime(Dom Domain, Flags uint32) (rDowntime uint64, err error) { + var buf []byte + + args := DomainMigrateGetMaxDowntimeArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(387, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Downtime: uint64 + _, err = dec.Decode(&rDowntime) + if err != nil { + return + } + + return +} + +// DomainManagedSaveGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_GET_XML_DESC. +func (l *Libvirt) DomainManagedSaveGetXMLDesc(Dom Domain, Flags DomainXMLFlags) (rXML string, err error) { + var buf []byte + + args := DomainManagedSaveGetXMLDescArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(388, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainManagedSaveDefineXML is the go wrapper for REMOTE_PROC_DOMAIN_MANAGED_SAVE_DEFINE_XML. +func (l *Libvirt) DomainManagedSaveDefineXML(Dom Domain, Dxml OptString, Flags DomainSaveRestoreFlags) (err error) { + var buf []byte + + args := DomainManagedSaveDefineXMLArgs { + Dom: Dom, + Dxml: Dxml, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(389, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainSetLifecycleAction is the go wrapper for REMOTE_PROC_DOMAIN_SET_LIFECYCLE_ACTION. +func (l *Libvirt) DomainSetLifecycleAction(Dom Domain, Type uint32, Action uint32, Flags DomainModificationImpact) (err error) { + var buf []byte + + args := DomainSetLifecycleActionArgs { + Dom: Dom, + Type: Type, + Action: Action, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(390, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// StoragePoolLookupByTargetPath is the go wrapper for REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_TARGET_PATH. +func (l *Libvirt) StoragePoolLookupByTargetPath(Path string) (rPool StoragePool, err error) { + var buf []byte + + args := StoragePoolLookupByTargetPathArgs { + Path: Path, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(391, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Pool: StoragePool + _, err = dec.Decode(&rPool) + if err != nil { + return + } + + return +} + +// DomainDetachDeviceAlias is the go wrapper for REMOTE_PROC_DOMAIN_DETACH_DEVICE_ALIAS. +func (l *Libvirt) DomainDetachDeviceAlias(Dom Domain, Alias string, Flags uint32) (err error) { + var buf []byte + + args := DomainDetachDeviceAliasArgs { + Dom: Dom, + Alias: Alias, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(392, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectCompareHypervisorCPU is the go wrapper for REMOTE_PROC_CONNECT_COMPARE_HYPERVISOR_CPU. +func (l *Libvirt) ConnectCompareHypervisorCPU(Emulator OptString, Arch OptString, Machine OptString, Virttype OptString, XMLCPU string, Flags uint32) (rResult int32, err error) { + var buf []byte + + args := ConnectCompareHypervisorCPUArgs { + Emulator: Emulator, + Arch: Arch, + Machine: Machine, + Virttype: Virttype, + XMLCPU: XMLCPU, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(393, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: int32 + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// ConnectBaselineHypervisorCPU is the go wrapper for REMOTE_PROC_CONNECT_BASELINE_HYPERVISOR_CPU. +func (l *Libvirt) ConnectBaselineHypervisorCPU(Emulator OptString, Arch OptString, Machine OptString, Virttype OptString, XMLCPUs []string, Flags uint32) (rCPU string, err error) { + var buf []byte + + args := ConnectBaselineHypervisorCPUArgs { + Emulator: Emulator, + Arch: Arch, + Machine: Machine, + Virttype: Virttype, + XMLCPUs: XMLCPUs, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(394, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // CPU: string + _, err = dec.Decode(&rCPU) + if err != nil { + return + } + + return +} + +// NodeGetSevInfo is the go wrapper for REMOTE_PROC_NODE_GET_SEV_INFO. +func (l *Libvirt) NodeGetSevInfo(Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := NodeGetSevInfoArgs { + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(395, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// DomainGetLaunchSecurityInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_LAUNCH_SECURITY_INFO. +func (l *Libvirt) DomainGetLaunchSecurityInfo(Dom Domain, Flags uint32) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetLaunchSecurityInfoArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(396, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// NwfilterBindingLookupByPortDev is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_LOOKUP_BY_PORT_DEV. +func (l *Libvirt) NwfilterBindingLookupByPortDev(Name string) (rOptNwfilter NwfilterBinding, err error) { + var buf []byte + + args := NwfilterBindingLookupByPortDevArgs { + Name: Name, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(397, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptNwfilter: NwfilterBinding + _, err = dec.Decode(&rOptNwfilter) + if err != nil { + return + } + + return +} + +// NwfilterBindingGetXMLDesc is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_GET_XML_DESC. +func (l *Libvirt) NwfilterBindingGetXMLDesc(OptNwfilter NwfilterBinding, Flags uint32) (rXML string, err error) { + var buf []byte + + args := NwfilterBindingGetXMLDescArgs { + OptNwfilter: OptNwfilter, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(398, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// NwfilterBindingCreateXML is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_CREATE_XML. +func (l *Libvirt) NwfilterBindingCreateXML(XML string, Flags uint32) (rOptNwfilter NwfilterBinding, err error) { + var buf []byte + + args := NwfilterBindingCreateXMLArgs { + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(399, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // OptNwfilter: NwfilterBinding + _, err = dec.Decode(&rOptNwfilter) + if err != nil { + return + } + + return +} + +// NwfilterBindingDelete is the go wrapper for REMOTE_PROC_NWFILTER_BINDING_DELETE. +func (l *Libvirt) NwfilterBindingDelete(OptNwfilter NwfilterBinding) (err error) { + var buf []byte + + args := NwfilterBindingDeleteArgs { + OptNwfilter: OptNwfilter, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(400, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectListAllNwfilterBindings is the go wrapper for REMOTE_PROC_CONNECT_LIST_ALL_NWFILTER_BINDINGS. +func (l *Libvirt) ConnectListAllNwfilterBindings(NeedResults int32, Flags uint32) (rBindings []NwfilterBinding, rRet uint32, err error) { + var buf []byte + + args := ConnectListAllNwfilterBindingsArgs { + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(401, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Bindings: []NwfilterBinding + _, err = dec.Decode(&rBindings) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainSetIothreadParams is the go wrapper for REMOTE_PROC_DOMAIN_SET_IOTHREAD_PARAMS. +func (l *Libvirt) DomainSetIothreadParams(Dom Domain, IothreadID uint32, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := DomainSetIothreadParamsArgs { + Dom: Dom, + IothreadID: IothreadID, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(402, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// ConnectGetStoragePoolCapabilities is the go wrapper for REMOTE_PROC_CONNECT_GET_STORAGE_POOL_CAPABILITIES. +func (l *Libvirt) ConnectGetStoragePoolCapabilities(Flags uint32) (rCapabilities string, err error) { + var buf []byte + + args := ConnectGetStoragePoolCapabilitiesArgs { + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(403, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Capabilities: string + _, err = dec.Decode(&rCapabilities) + if err != nil { + return + } + + return +} + +// NetworkListAllPorts is the go wrapper for REMOTE_PROC_NETWORK_LIST_ALL_PORTS. +func (l *Libvirt) NetworkListAllPorts(OptNetwork Network, NeedResults int32, Flags uint32) (rPorts []NetworkPort, rRet uint32, err error) { + var buf []byte + + args := NetworkListAllPortsArgs { + OptNetwork: OptNetwork, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(404, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Ports: []NetworkPort + _, err = dec.Decode(&rPorts) + if err != nil { + return + } + // Ret: uint32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// NetworkPortLookupByUUID is the go wrapper for REMOTE_PROC_NETWORK_PORT_LOOKUP_BY_UUID. +func (l *Libvirt) NetworkPortLookupByUUID(OptNetwork Network, UUID UUID) (rPort NetworkPort, err error) { + var buf []byte + + args := NetworkPortLookupByUUIDArgs { + OptNetwork: OptNetwork, + UUID: UUID, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(405, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Port: NetworkPort + _, err = dec.Decode(&rPort) + if err != nil { + return + } + + return +} + +// NetworkPortCreateXML is the go wrapper for REMOTE_PROC_NETWORK_PORT_CREATE_XML. +func (l *Libvirt) NetworkPortCreateXML(OptNetwork Network, XML string, Flags uint32) (rPort NetworkPort, err error) { + var buf []byte + + args := NetworkPortCreateXMLArgs { + OptNetwork: OptNetwork, + XML: XML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(406, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Port: NetworkPort + _, err = dec.Decode(&rPort) + if err != nil { + return + } + + return +} + +// NetworkPortGetParameters is the go wrapper for REMOTE_PROC_NETWORK_PORT_GET_PARAMETERS. +func (l *Libvirt) NetworkPortGetParameters(Port NetworkPort, Nparams int32, Flags uint32) (rParams []TypedParam, rNparams int32, err error) { + var buf []byte + + args := NetworkPortGetParametersArgs { + Port: Port, + Nparams: Nparams, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(407, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + // Nparams: int32 + _, err = dec.Decode(&rNparams) + if err != nil { + return + } + + return +} + +// NetworkPortSetParameters is the go wrapper for REMOTE_PROC_NETWORK_PORT_SET_PARAMETERS. +func (l *Libvirt) NetworkPortSetParameters(Port NetworkPort, Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := NetworkPortSetParametersArgs { + Port: Port, + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(408, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// NetworkPortGetXMLDesc is the go wrapper for REMOTE_PROC_NETWORK_PORT_GET_XML_DESC. +func (l *Libvirt) NetworkPortGetXMLDesc(Port NetworkPort, Flags uint32) (rXML string, err error) { + var buf []byte + + args := NetworkPortGetXMLDescArgs { + Port: Port, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(409, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// NetworkPortDelete is the go wrapper for REMOTE_PROC_NETWORK_PORT_DELETE. +func (l *Libvirt) NetworkPortDelete(Port NetworkPort, Flags uint32) (err error) { + var buf []byte + + args := NetworkPortDeleteArgs { + Port: Port, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(410, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainCheckpointCreateXML is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_CREATE_XML. +func (l *Libvirt) DomainCheckpointCreateXML(Dom Domain, XMLDesc string, Flags uint32) (rCheckpoint DomainCheckpoint, err error) { + var buf []byte + + args := DomainCheckpointCreateXMLArgs { + Dom: Dom, + XMLDesc: XMLDesc, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(411, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Checkpoint: DomainCheckpoint + _, err = dec.Decode(&rCheckpoint) + if err != nil { + return + } + + return +} + +// DomainCheckpointGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_GET_XML_DESC. +func (l *Libvirt) DomainCheckpointGetXMLDesc(Checkpoint DomainCheckpoint, Flags uint32) (rXML string, err error) { + var buf []byte + + args := DomainCheckpointGetXMLDescArgs { + Checkpoint: Checkpoint, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(412, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainListAllCheckpoints is the go wrapper for REMOTE_PROC_DOMAIN_LIST_ALL_CHECKPOINTS. +func (l *Libvirt) DomainListAllCheckpoints(Dom Domain, NeedResults int32, Flags uint32) (rCheckpoints []DomainCheckpoint, rRet int32, err error) { + var buf []byte + + args := DomainListAllCheckpointsArgs { + Dom: Dom, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(413, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Checkpoints: []DomainCheckpoint + _, err = dec.Decode(&rCheckpoints) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainCheckpointListAllChildren is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_LIST_ALL_CHILDREN. +func (l *Libvirt) DomainCheckpointListAllChildren(Checkpoint DomainCheckpoint, NeedResults int32, Flags uint32) (rCheckpoints []DomainCheckpoint, rRet int32, err error) { + var buf []byte + + args := DomainCheckpointListAllChildrenArgs { + Checkpoint: Checkpoint, + NeedResults: NeedResults, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(414, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Checkpoints: []DomainCheckpoint + _, err = dec.Decode(&rCheckpoints) + if err != nil { + return + } + // Ret: int32 + _, err = dec.Decode(&rRet) + if err != nil { + return + } + + return +} + +// DomainCheckpointLookupByName is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_LOOKUP_BY_NAME. +func (l *Libvirt) DomainCheckpointLookupByName(Dom Domain, Name string, Flags uint32) (rCheckpoint DomainCheckpoint, err error) { + var buf []byte + + args := DomainCheckpointLookupByNameArgs { + Dom: Dom, + Name: Name, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(415, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Checkpoint: DomainCheckpoint + _, err = dec.Decode(&rCheckpoint) + if err != nil { + return + } + + return +} + +// DomainCheckpointGetParent is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_GET_PARENT. +func (l *Libvirt) DomainCheckpointGetParent(Checkpoint DomainCheckpoint, Flags uint32) (rParent DomainCheckpoint, err error) { + var buf []byte + + args := DomainCheckpointGetParentArgs { + Checkpoint: Checkpoint, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(416, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Parent: DomainCheckpoint + _, err = dec.Decode(&rParent) + if err != nil { + return + } + + return +} + +// DomainCheckpointDelete is the go wrapper for REMOTE_PROC_DOMAIN_CHECKPOINT_DELETE. +func (l *Libvirt) DomainCheckpointDelete(Checkpoint DomainCheckpoint, Flags DomainCheckpointDeleteFlags) (err error) { + var buf []byte + + args := DomainCheckpointDeleteArgs { + Checkpoint: Checkpoint, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(417, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainGetGuestInfo is the go wrapper for REMOTE_PROC_DOMAIN_GET_GUEST_INFO. +func (l *Libvirt) DomainGetGuestInfo(Dom Domain, Types uint32, Flags uint32) (rParams []TypedParam, err error) { + var buf []byte + + args := DomainGetGuestInfoArgs { + Dom: Dom, + Types: Types, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(418, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Params: []TypedParam + _, err = dec.Decode(&rParams) + if err != nil { + return + } + + return +} + +// ConnectSetIdentity is the go wrapper for REMOTE_PROC_CONNECT_SET_IDENTITY. +func (l *Libvirt) ConnectSetIdentity(Params []TypedParam, Flags uint32) (err error) { + var buf []byte + + args := ConnectSetIdentityArgs { + Params: Params, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(419, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainAgentSetResponseTimeout is the go wrapper for REMOTE_PROC_DOMAIN_AGENT_SET_RESPONSE_TIMEOUT. +func (l *Libvirt) DomainAgentSetResponseTimeout(Dom Domain, Timeout int32, Flags uint32) (rResult int32, err error) { + var buf []byte + + args := DomainAgentSetResponseTimeoutArgs { + Dom: Dom, + Timeout: Timeout, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(420, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Result: int32 + _, err = dec.Decode(&rResult) + if err != nil { + return + } + + return +} + +// DomainBackupBegin is the go wrapper for REMOTE_PROC_DOMAIN_BACKUP_BEGIN. +func (l *Libvirt) DomainBackupBegin(Dom Domain, BackupXML string, CheckpointXML OptString, Flags DomainBackupBeginFlags) (err error) { + var buf []byte + + args := DomainBackupBeginArgs { + Dom: Dom, + BackupXML: BackupXML, + CheckpointXML: CheckpointXML, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(421, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainBackupGetXMLDesc is the go wrapper for REMOTE_PROC_DOMAIN_BACKUP_GET_XML_DESC. +func (l *Libvirt) DomainBackupGetXMLDesc(Dom Domain, Flags uint32) (rXML string, err error) { + var buf []byte + + args := DomainBackupGetXMLDescArgs { + Dom: Dom, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(422, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // XML: string + _, err = dec.Decode(&rXML) + if err != nil { + return + } + + return +} + +// DomainEventMemoryFailure is the go wrapper for REMOTE_PROC_DOMAIN_EVENT_MEMORY_FAILURE. +func (l *Libvirt) DomainEventMemoryFailure() (err error) { + var buf []byte + + + _, err = l.requestStream(423, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + +// DomainAuthorizedSshKeysGet is the go wrapper for REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_GET. +func (l *Libvirt) DomainAuthorizedSshKeysGet(Dom Domain, User string, Flags uint32) (rKeys []string, err error) { + var buf []byte + + args := DomainAuthorizedSshKeysGetArgs { + Dom: Dom, + User: User, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + var r response + r, err = l.requestStream(424, constants.Program, buf, nil, nil) + if err != nil { + return + } + + // Return value unmarshaling + tpd := typedParamDecoder{} + ct := map[string]xdr.TypeDecoder{"libvirt.TypedParam": tpd} + rdr := bytes.NewReader(r.Payload) + dec := xdr.NewDecoderCustomTypes(rdr, 0, ct) + // Keys: []string + _, err = dec.Decode(&rKeys) + if err != nil { + return + } + + return +} + +// DomainAuthorizedSshKeysSet is the go wrapper for REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_SET. +func (l *Libvirt) DomainAuthorizedSshKeysSet(Dom Domain, User string, Keys []string, Flags uint32) (err error) { + var buf []byte + + args := DomainAuthorizedSshKeysSetArgs { + Dom: Dom, + User: User, + Keys: Keys, + Flags: Flags, + } + + buf, err = encode(&args) + if err != nil { + return + } + + + _, err = l.requestStream(425, constants.Program, buf, nil, nil) + if err != nil { + return + } + + return +} + diff --git a/vendor/github.com/digitalocean/go-libvirt/rpc.go b/vendor/github.com/digitalocean/go-libvirt/rpc.go new file mode 100644 index 000000000..8181e0991 --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/rpc.go @@ -0,0 +1,606 @@ +// Copyright 2018 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package libvirt + +import ( + "bytes" + "encoding/binary" + "errors" + "fmt" + "io" + "reflect" + "strings" + "sync/atomic" + "unsafe" + + "github.com/digitalocean/go-libvirt/internal/constants" + "github.com/digitalocean/go-libvirt/internal/event" + xdr "github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2" +) + +// ErrUnsupported is returned if a procedure is not supported by libvirt +var ErrUnsupported = errors.New("unsupported procedure requested") + +// request and response types +const ( + // Call is used when making calls to the remote server. + Call = iota + + // Reply indicates a server reply. + Reply + + // Message is an asynchronous notification. + Message + + // Stream represents a stream data packet. + Stream + + // CallWithFDs is used by a client to indicate the request has + // arguments with file descriptors. + CallWithFDs + + // ReplyWithFDs is used by a server to indicate the request has + // arguments with file descriptors. + ReplyWithFDs +) + +// request and response statuses +const ( + // StatusOK is always set for method calls or events. + // For replies it indicates successful completion of the method. + // For streams it indicates confirmation of the end of file on the stream. + StatusOK = iota + + // StatusError for replies indicates that the method call failed + // and error information is being returned. For streams this indicates + // that not all data was sent and the stream has aborted. + StatusError + + // StatusContinue is only used for streams. + // This indicates that further data packets will be following. + StatusContinue +) + +// header is a libvirt rpc packet header +type header struct { + // Program identifier + Program uint32 + + // Program version + Version uint32 + + // Remote procedure identifier + Procedure uint32 + + // Call type, e.g., Reply + Type uint32 + + // Call serial number + Serial int32 + + // Request status, e.g., StatusOK + Status uint32 +} + +// packet represents a RPC request or response. +type packet struct { + // Size of packet, in bytes, including length. + // Len + Header + Payload + Len uint32 + Header header +} + +// Global packet instance, for use with unsafe.Sizeof() +var _p packet + +// internal rpc response +type response struct { + Payload []byte + Status uint32 +} + +// libvirt error response +type libvirtError struct { + Code uint32 + DomainID uint32 + Padding uint8 + Message string + Level uint32 +} + +func (e libvirtError) Error() string { + return e.Message +} + +// checkError is used to check whether an error is a libvirtError, and if it is, +// whether its error code matches the one passed in. It will return false if +// these conditions are not met. +func checkError(err error, expectedError errorNumber) bool { + e, ok := err.(libvirtError) + if ok { + return e.Code == uint32(expectedError) + } + return false +} + +// IsNotFound detects libvirt's ERR_NO_DOMAIN. +func IsNotFound(err error) bool { + return checkError(err, errNoDomain) +} + +// listen processes incoming data and routes +// responses to their respective callback handler. +func (l *Libvirt) listen() { + for { + // response packet length + length, err := pktlen(l.r) + if err != nil { + // When the underlying connection EOFs or is closed, stop + // this goroutine + if err == io.EOF || strings.Contains(err.Error(), "use of closed network connection") { + return + } + + // invalid packet + continue + } + + // response header + h, err := extractHeader(l.r) + if err != nil { + // invalid packet + continue + } + + // payload: packet length minus what was previously read + size := int(length) - int(unsafe.Sizeof(_p)) + buf := make([]byte, size) + _, err = io.ReadFull(l.r, buf) + if err != nil { + // invalid packet + continue + } + + // route response to caller + l.route(h, buf) + } +} + +// callback sends RPC responses to respective callers. +func (l *Libvirt) callback(id int32, res response) { + l.cmux.Lock() + defer l.cmux.Unlock() + + c, ok := l.callbacks[id] + if !ok { + return + } + + c <- res +} + +// route sends incoming packets to their listeners. +func (l *Libvirt) route(h *header, buf []byte) { + // route events to their respective listener + var event event.Event + + switch { + case h.Program == constants.QEMUProgram && h.Procedure == constants.QEMUProcDomainMonitorEvent: + event = &DomainEvent{} + case h.Program == constants.Program && h.Procedure == constants.ProcDomainEventCallbackLifecycle: + event = &DomainEventCallbackLifecycleMsg{} + } + + if event != nil { + err := eventDecoder(buf, event) + if err != nil { // event was malformed, drop. + return + } + + l.stream(event) + return + } + + // send response to caller + l.callback(h.Serial, response{Payload: buf, Status: h.Status}) +} + +// serial provides atomic access to the next sequential request serial number. +func (l *Libvirt) serial() int32 { + return atomic.AddInt32(&l.s, 1) +} + +// stream decodes and relays domain events to their respective listener. +func (l *Libvirt) stream(e event.Event) { + l.emux.RLock() + defer l.emux.RUnlock() + + q, ok := l.events[e.GetCallbackID()] + if !ok { + return + } + + q.Push(e) +} + +// addStream configures the routing for an event stream. +func (l *Libvirt) addStream(s *event.Stream) { + l.emux.Lock() + defer l.emux.Unlock() + + l.events[s.CallbackID] = s +} + +// removeStream notifies the libvirt server to stop sending events for the +// provided callback ID. Upon successful de-registration the callback handler +// is destroyed. Subsequent calls to removeStream are idempotent and return +// nil. +// TODO: Fix this comment +func (l *Libvirt) removeStream(id int32) error { + l.emux.Lock() + defer l.emux.Unlock() + + // if the event is already removed, just return nil + _, ok := l.events[id] + if ok { + delete(l.events, id) + } + + return nil +} + +// register configures a method response callback +func (l *Libvirt) register(id int32, c chan response) { + l.cmux.Lock() + defer l.cmux.Unlock() + + l.callbacks[id] = c +} + +// deregister destroys a method response callback. It is the responsibility of +// the caller to manage locking (l.cmux) during this call. +func (l *Libvirt) deregister(id int32) { + _, ok := l.callbacks[id] + if !ok { + return + } + + close(l.callbacks[id]) + delete(l.callbacks, id) +} + +// deregisterAll closes all waiting callback channels. This is used to clean up +// if the connection to libvirt is lost. Callers waiting for responses will +// return an error when the response channel is closed, rather than just +// hanging. +func (l *Libvirt) deregisterAll() { + l.cmux.Lock() + defer l.cmux.Unlock() + + for id := range l.callbacks { + l.deregister(id) + } +} + +// request performs a libvirt RPC request. +// returns response returned by server. +// if response is not OK, decodes error from it and returns it. +func (l *Libvirt) request(proc uint32, program uint32, payload []byte) (response, error) { + return l.requestStream(proc, program, payload, nil, nil) +} + +// requestStream performs a libvirt RPC request. The `out` and `in` parameters +// are optional, and should be nil when RPC endpoints don't return a stream. +func (l *Libvirt) requestStream(proc uint32, program uint32, payload []byte, + out io.Reader, in io.Writer) (response, error) { + serial := l.serial() + c := make(chan response) + + l.register(serial, c) + defer func() { + l.cmux.Lock() + defer l.cmux.Unlock() + + l.deregister(serial) + }() + + err := l.sendPacket(serial, proc, program, payload, Call, StatusOK) + if err != nil { + return response{}, err + } + + resp, err := l.getResponse(c) + if err != nil { + return resp, err + } + + if out != nil { + abort := make(chan bool) + outErr := make(chan error) + go func() { + outErr <- l.sendStream(serial, proc, program, out, abort) + }() + + // Even without incoming stream server sends confirmation once all data is received + resp, err = l.processIncomingStream(c, in) + if err != nil { + abort <- true + return resp, err + } + + err = <-outErr + if err != nil { + return response{}, err + } + } + + switch in { + case nil: + return resp, nil + default: + return l.processIncomingStream(c, in) + } +} + +// processIncomingStream is called once we've successfully sent a request to +// libvirt. It writes the responses back to the stream passed by the caller +// until libvirt sends a packet with statusOK or an error. +func (l *Libvirt) processIncomingStream(c chan response, inStream io.Writer) (response, error) { + for { + resp, err := l.getResponse(c) + if err != nil { + return resp, err + } + + // StatusOK indicates end of stream + if resp.Status == StatusOK { + return resp, nil + } + + // FIXME: this smells. + // StatusError is handled in getResponse, so this must be StatusContinue + // StatusContinue is only valid here for stream packets + // libvirtd breaks protocol and returns StatusContinue with an + // empty response Payload when the stream finishes + if len(resp.Payload) == 0 { + return resp, nil + } + if inStream != nil { + _, err = inStream.Write(resp.Payload) + if err != nil { + return response{}, err + } + } + } +} + +func (l *Libvirt) sendStream(serial int32, proc uint32, program uint32, stream io.Reader, abort chan bool) error { + // Keep total packet length under 4 MiB to follow possible limitation in libvirt server code + buf := make([]byte, 4*MiB-unsafe.Sizeof(_p)) + for { + select { + case <-abort: + return l.sendPacket(serial, proc, program, nil, Stream, StatusError) + default: + } + n, err := stream.Read(buf) + if n > 0 { + err2 := l.sendPacket(serial, proc, program, buf[:n], Stream, StatusContinue) + if err2 != nil { + return err2 + } + } + if err != nil { + if err == io.EOF { + return l.sendPacket(serial, proc, program, nil, Stream, StatusOK) + } + // keep original error + err2 := l.sendPacket(serial, proc, program, nil, Stream, StatusError) + if err2 != nil { + return err2 + } + return err + } + } +} + +func (l *Libvirt) sendPacket(serial int32, proc uint32, program uint32, payload []byte, typ uint32, status uint32) error { + + p := packet{ + Header: header{ + Program: program, + Version: constants.ProtocolVersion, + Procedure: proc, + Type: typ, + Serial: serial, + Status: status, + }, + } + + size := int(unsafe.Sizeof(p.Len)) + int(unsafe.Sizeof(p.Header)) + if payload != nil { + size += len(payload) + } + p.Len = uint32(size) + + // write header + l.mu.Lock() + defer l.mu.Unlock() + err := binary.Write(l.w, binary.BigEndian, p) + if err != nil { + return err + } + + // write payload + if payload != nil { + err = binary.Write(l.w, binary.BigEndian, payload) + if err != nil { + return err + } + } + + return l.w.Flush() +} + +func (l *Libvirt) getResponse(c chan response) (response, error) { + resp := <-c + if resp.Status == StatusError { + return resp, decodeError(resp.Payload) + } + + return resp, nil +} + +// encode XDR encodes the provided data. +func encode(data interface{}) ([]byte, error) { + var buf bytes.Buffer + _, err := xdr.Marshal(&buf, data) + + return buf.Bytes(), err +} + +// decodeError extracts an error message from the provider buffer. +func decodeError(buf []byte) error { + var e libvirtError + + dec := xdr.NewDecoder(bytes.NewReader(buf)) + _, err := dec.Decode(&e) + if err != nil { + return err + } + + if strings.Contains(e.Message, "unknown procedure") { + return ErrUnsupported + } + // if libvirt returns ERR_OK, ignore the error + if checkError(e, errOk) { + return nil + } + + return e +} + +// eventDecoder decodes an event from a xdr buffer. +func eventDecoder(buf []byte, e interface{}) error { + dec := xdr.NewDecoder(bytes.NewReader(buf)) + _, err := dec.Decode(e) + return err +} + +// pktlen returns the length of an incoming RPC packet. Read errors will +// result in a returned response length of 0 and a non-nil error. +func pktlen(r io.Reader) (uint32, error) { + buf := make([]byte, unsafe.Sizeof(_p.Len)) + + // extract the packet's length from the header + _, err := io.ReadFull(r, buf) + if err != nil { + return 0, err + } + + return binary.BigEndian.Uint32(buf), nil +} + +// extractHeader returns the decoded header from an incoming response. +func extractHeader(r io.Reader) (*header, error) { + buf := make([]byte, unsafe.Sizeof(_p.Header)) + + // extract the packet's header from r + _, err := io.ReadFull(r, buf) + if err != nil { + return nil, err + } + + return &header{ + Program: binary.BigEndian.Uint32(buf[0:4]), + Version: binary.BigEndian.Uint32(buf[4:8]), + Procedure: binary.BigEndian.Uint32(buf[8:12]), + Type: binary.BigEndian.Uint32(buf[12:16]), + Serial: int32(binary.BigEndian.Uint32(buf[16:20])), + Status: binary.BigEndian.Uint32(buf[20:24]), + }, nil +} + +type typedParamDecoder struct{} + +// Decode decodes a TypedParam. These are part of the libvirt spec, and not xdr +// proper. TypedParams contain a name, which is called Field for some reason, +// and a Value, which itself has a "discriminant" - an integer enum encoding the +// actual type, and a value, the length of which varies based on the actual +// type. +func (tpd typedParamDecoder) Decode(d *xdr.Decoder, v reflect.Value) (int, error) { + // Get the name of the typed param first + name, n, err := d.DecodeString() + if err != nil { + return n, err + } + val, n2, err := tpd.decodeTypedParamValue(d) + n += n2 + if err != nil { + return n, err + } + tp := &TypedParam{Field: name, Value: *val} + v.Set(reflect.ValueOf(*tp)) + + return n, nil +} + +// decodeTypedParamValue decodes the Value part of a TypedParam. +func (typedParamDecoder) decodeTypedParamValue(d *xdr.Decoder) (*TypedParamValue, int, error) { + // All TypedParamValues begin with a uint32 discriminant that tells us what + // type they are. + discriminant, n, err := d.DecodeUint() + if err != nil { + return nil, n, err + } + var n2 int + var tpv *TypedParamValue + switch discriminant { + case 1: + var val int32 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 2: + var val uint32 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 3: + var val int64 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 4: + var val uint64 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 5: + var val float64 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 6: + var val int32 + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + case 7: + var val string + n2, err = d.Decode(&val) + tpv = &TypedParamValue{D: discriminant, I: val} + + default: + err = fmt.Errorf("invalid parameter type %v", discriminant) + } + n += n2 + + return tpv, n, err +} diff --git a/vendor/github.com/digitalocean/go-libvirt/units.go b/vendor/github.com/digitalocean/go-libvirt/units.go new file mode 100644 index 000000000..03686507f --- /dev/null +++ b/vendor/github.com/digitalocean/go-libvirt/units.go @@ -0,0 +1,27 @@ +// Copyright 2016 The go-libvirt Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// This module provides different units of measurement to make other +// code more readable. + +package libvirt + +const ( + // B - byte + B = 1 + // KiB - kibibyte + KiB = 1024 * B + // MiB - mebibyte + MiB = 1024 * KiB +) diff --git a/vendor/github.com/digitalocean/go-qemu/AUTHORS b/vendor/github.com/digitalocean/go-qemu/AUTHORS new file mode 100644 index 000000000..e2836c3c7 --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/AUTHORS @@ -0,0 +1,17 @@ +Maintainer +---------- +DigitalOcean, Inc + +Original Authors +---------------- +Ben LeMasurier <blemasurier@digitalocean.com> +Matt Layher <mlayher@digitalocean.com> + +Contributors +------------ +David Anderson <dave@natulte.net> +Justin Kim <justin@digitalocean.com> +Luis Sagastume <lsagastume1990@gmail.com> +Nedim Dedic <nedim_dedic@yahoo.com> +Roberto J Rojas <robertojrojas@gmail.com> +Marko Mudrinic <mudrinic.mare@gmail.com> diff --git a/vendor/github.com/digitalocean/go-qemu/LICENSE.md b/vendor/github.com/digitalocean/go-qemu/LICENSE.md new file mode 100644 index 000000000..f5f4b8b5e --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/LICENSE.md @@ -0,0 +1,195 @@ +Apache License +============== + +_Version 2.0, January 2004_ +_<<http://www.apache.org/licenses/>>_ + +### Terms and Conditions for use, reproduction, and distribution + +#### 1. Definitions + +“License” shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +“Licensor” shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +“Legal Entity” shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, “control” means **(i)** the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the +outstanding shares, or **(iii)** beneficial ownership of such entity. + +“You” (or “Your”) shall mean an individual or Legal Entity exercising +permissions granted by this License. + +“Source” form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +“Object” form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +“Work” shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +“Derivative Works” shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +“Contribution” shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +“submitted” means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as “Not a Contribution.” + +“Contributor” shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +#### 2. Grant of Copyright License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +#### 3. Grant of Patent License + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +#### 4. Redistribution + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +* **(a)** You must give any other recipients of the Work or Derivative Works a copy of +this License; and +* **(b)** You must cause any modified files to carry prominent notices stating that You +changed the files; and +* **(c)** You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. + +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +#### 5. Submission of Contributions + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +#### 6. Trademarks + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +#### 7. Disclaimer of Warranty + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an “AS IS” BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +#### 8. Limitation of Liability + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +#### 9. Accepting Warranty or Additional Liability + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +_END OF TERMS AND CONDITIONS_ + +### APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets `[]` replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same “printed page” as the copyright notice for easier identification within +third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/README.md b/vendor/github.com/digitalocean/go-qemu/qmp/README.md new file mode 100644 index 000000000..729280b31 --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/README.md @@ -0,0 +1,104 @@ +QMP +=== + +Package `qmp` enables interaction with QEMU instances via the QEMU Machine Protocol (QMP). + +## Available Drivers + +### Libvirt + +If your environment is managed by Libvirt, QMP interaction must be proxied through the Libvirt daemon. This can be be done through two available drivers: + +#### RPC + +The RPC driver provides a pure Go implementation of Libvirt's RPC protocol. + +```go +//conn, err := net.DialTimeout("unix", "/var/run/libvirt/libvirt-sock", 2*time.Second) +conn, err := net.DialTimeout("tcp", "192.168.1.1:16509", 2*time.Second) +monitor := libvirtrpc.New("stage-lb-1", conn) +``` + +#### virsh + +A connection to the monitor socket is provided by proxing requests through the `virsh` executable. + +```go +monitor, err := qmp.NewLibvirtMonitor("qemu:///system", "stage-lb-1") +``` + +### Socket + +If your QEMU instances are not managed by libvirt, direct communication over its UNIX socket is available. + +```go +monitor, err := qmp.NewSocketMonitor("unix", "/var/lib/qemu/example.monitor", 2*time.Second) +``` + +## Examples + +Using the above to establish a new `qmp.Monitor`, the following examples provide a brief overview of QMP usage. + +_error checking omitted for the sake of brevity._ + +### Command Execution +```go +type StatusResult struct { + ID string `json:"id"` + Return struct { + Running bool `json:"running"` + Singlestep bool `json:"singlestep"` + Status string `json:"status"` + } `json:"return"` +} + +monitor.Connect() +defer monitor.Disconnect() + +cmd := []byte(`{ "execute": "query-status" }`) +raw, _ := monitor.Run(cmd) + +var result StatusResult +json.Unmarshal(raw, &result) + +fmt.Println(result.Return.Status) +``` + +``` +running +``` + +### Event Monitor + +```go +monitor.Connect() +defer monitor.Disconnect() + +stream, _ := monitor.Events() +for e := range stream { + log.Printf("EVENT: %s", e.Event) +} + +``` + +``` +$ virsh reboot example +Domain example is being rebooted +``` + +``` +EVENT: POWERDOWN +EVENT: SHUTDOWN +EVENT: STOP +EVENT: RESET +EVENT: RESUME +EVENT: RESET +... +``` + +## More information + +* [QEMU QMP Wiki](http://wiki.qemu.org/QMP) +* [QEMU QMP Intro](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-intro.txt;hb=HEAD) +* [QEMU QMP Events](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-events.txt;hb=HEAD) +* [QEMU QMP Spec](http://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/qmp-spec.txt;hb=HEAD) diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go b/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go new file mode 100644 index 000000000..b856260d3 --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/qmp.go @@ -0,0 +1,94 @@ +// Copyright 2016 The go-qemu Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package qmp enables interaction with QEMU instances +// via the QEMU Machine Protocol (QMP). +package qmp + +import ( + "context" + "errors" + "fmt" +) + +// ErrEventsNotSupported is returned by Events() if event streams +// are unsupported by either QEMU or libvirt. +var ErrEventsNotSupported = errors.New("event monitor is not supported") + +// Monitor represents a QEMU Machine Protocol socket. +// See: http://wiki.qemu.org/QMP +type Monitor interface { + Connect() error + Disconnect() error + Run(command []byte) (out []byte, err error) + Events(context.Context) (events <-chan Event, err error) +} + +// Command represents a QMP command. +type Command struct { + // Name of the command to run + Execute string `json:"execute"` + + // Optional arguments for the above command. + Args interface{} `json:"arguments,omitempty"` +} + +type response struct { + ID string `json:"id"` + Return interface{} `json:"return,omitempty"` + Error struct { + Class string `json:"class"` + Desc string `json:"desc"` + } `json:"error,omitempty"` +} + +func (r *response) Err() error { + if r.Error.Desc == "" { + return nil + } + + return errors.New(r.Error.Desc) +} + +// Event represents a QEMU QMP event. +// See http://wiki.qemu.org/QMP +type Event struct { + // Event name, e.g., BLOCK_JOB_COMPLETE + Event string `json:"event"` + + // Arbitrary event data + Data map[string]interface{} `json:"data"` + + // Event timestamp, provided by QEMU. + Timestamp struct { + Seconds int64 `json:"seconds"` + Microseconds int64 `json:"microseconds"` + } `json:"timestamp"` +} + +// Version is the QEMU version structure returned when a QMP connection is +// initiated. +type Version struct { + Package string `json:"package"` + QEMU struct { + Major int `json:"major"` + Micro int `json:"micro"` + Minor int `json:"minor"` + } `json:"qemu"` +} + +func (v Version) String() string { + q := v.QEMU + return fmt.Sprintf("%d.%d.%d", q.Major, q.Minor, q.Micro) +} diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go b/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go new file mode 100644 index 000000000..cb11c71fe --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/rpc.go @@ -0,0 +1,107 @@ +// Copyright 2016 The go-qemu Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package qmp + +import ( + "context" + "encoding/json" + "net" + + "github.com/digitalocean/go-libvirt" +) + +var _ Monitor = &LibvirtRPCMonitor{} + +// A LibvirtRPCMonitor implements LibVirt's remote procedure call protocol. +type LibvirtRPCMonitor struct { + l *libvirt.Libvirt + // Domain name as seen by libvirt, e.g., stage-lb-1 + Domain string +} + +// NewLibvirtRPCMonitor configures a new Libvirt RPC Monitor connection. +// The provided domain should be the name of the domain as seen +// by libvirt, e.g., stage-lb-1. +func NewLibvirtRPCMonitor(domain string, conn net.Conn) *LibvirtRPCMonitor { + l := libvirt.New(conn) + + return &LibvirtRPCMonitor{ + l: l, + Domain: domain, + } +} + +// Connect establishes communication with the libvirt server. +// The underlying libvirt socket connection must be previously established. +func (rpc *LibvirtRPCMonitor) Connect() error { + return rpc.l.Connect() +} + +// Disconnect shuts down communication with the libvirt server +// and closes the underlying net.Conn. +func (rpc *LibvirtRPCMonitor) Disconnect() error { + return rpc.l.Disconnect() +} + +// Events streams QEMU QMP Events until the provided context is cancelled. +// If a problem is encountered setting up the event monitor connection +// an error will be returned. Errors encountered during streaming will +// cause the returned event channel to be closed. +func (rpc *LibvirtRPCMonitor) Events(ctx context.Context) (<-chan Event, error) { + events, err := rpc.l.SubscribeQEMUEvents(ctx, rpc.Domain) + if err != nil { + return nil, err + } + + c := make(chan Event) + go func() { + // process events + for e := range events { + qe, err := qmpEvent(&e) + if err != nil { + close(c) + break + } + + c <- *qe + } + }() + + return c, nil +} + +// Run executes the given QAPI command against a domain's QEMU instance. +// For a list of available QAPI commands, see: +// http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD +func (rpc *LibvirtRPCMonitor) Run(cmd []byte) ([]byte, error) { + return rpc.l.Run(rpc.Domain, cmd) +} + +// qmpEvent takes a libvirt DomainEvent and returns the QMP equivalent. +func qmpEvent(e *libvirt.DomainEvent) (*Event, error) { + var qe Event + + if e.Details != nil { + if err := json.Unmarshal(e.Details, &qe.Data); err != nil { + return nil, err + } + } + + qe.Event = e.Event + qe.Timestamp.Seconds = int64(e.Seconds) + qe.Timestamp.Microseconds = int64(e.Microseconds) + + return &qe, nil +} diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket.go new file mode 100644 index 000000000..541a88676 --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket.go @@ -0,0 +1,274 @@ +// Copyright 2016 The go-qemu Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package qmp + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "io" + "net" + "os" + "sync" + "sync/atomic" + "time" +) + +// A SocketMonitor is a Monitor which speaks directly to a QEMU Machine Protocol +// (QMP) socket. Communication is performed directly using a QEMU monitor socket, +// typically using a UNIX socket or TCP connection. Multiple connections to the +// same domain are not permitted, and will result in the monitor blocking until +// the existing connection is closed. +type SocketMonitor struct { + // QEMU version reported by a connected monitor socket. + Version *Version + + // QEMU QMP capabiltiies reported by a connected monitor socket. + Capabilities []string + + // Underlying connection + c net.Conn + + // Serialize running command against domain + mu sync.Mutex + + // Send command responses and errors + stream <-chan streamResponse + + // Send domain events to listeners when available + listeners *int32 + events <-chan Event +} + +// NewSocketMonitor configures a connection to the provided QEMU monitor socket. +// An error is returned if the socket cannot be successfully dialed, or the +// dial attempt times out. +// +// NewSocketMonitor may dial the QEMU socket using a variety of connection types: +// NewSocketMonitor("unix", "/var/lib/qemu/example.monitor", 2 * time.Second) +// NewSocketMonitor("tcp", "8.8.8.8:4444", 2 * time.Second) +func NewSocketMonitor(network, addr string, timeout time.Duration) (*SocketMonitor, error) { + c, err := net.DialTimeout(network, addr, timeout) + if err != nil { + return nil, err + } + + mon := &SocketMonitor{ + c: c, + listeners: new(int32), + } + + return mon, nil +} + +// Listen creates a new SocketMonitor listening for a single connection to the provided socket file or address. +// An error is returned if unable to listen at the specified file path or port. +// +// Listen will wait for a QEMU socket connection using a variety connection types: +// Listen("unix", "/var/lib/qemu/example.monitor") +// Listen("tcp", "0.0.0.0:4444") +func Listen(network, addr string) (*SocketMonitor, error) { + l, err := net.Listen(network, addr) + if err != nil { + return nil, err + } + c, err := l.Accept() + defer l.Close() + if err != nil { + return nil, err + } + + mon := &SocketMonitor{ + c: c, + listeners: new(int32), + } + + return mon, nil +} + +// Disconnect closes the QEMU monitor socket connection. +func (mon *SocketMonitor) Disconnect() error { + atomic.StoreInt32(mon.listeners, 0) + err := mon.c.Close() + + return err +} + +// qmpCapabilities is the command which must be executed to perform the +// QEMU QMP handshake. +const qmpCapabilities = "qmp_capabilities" + +// Connect sets up a QEMU QMP connection by connecting directly to the QEMU +// monitor socket. An error is returned if the capabilities handshake does +// not succeed. +func (mon *SocketMonitor) Connect() error { + enc := json.NewEncoder(mon.c) + dec := json.NewDecoder(mon.c) + + // Check for banner on startup + var ban banner + if err := dec.Decode(&ban); err != nil { + return err + } + mon.Version = &ban.QMP.Version + mon.Capabilities = ban.QMP.Capabilities + + // Issue capabilities handshake + cmd := Command{Execute: qmpCapabilities} + if err := enc.Encode(cmd); err != nil { + return err + } + + // Check for no error on return + var r response + if err := dec.Decode(&r); err != nil { + return err + } + if err := r.Err(); err != nil { + return err + } + + // Initialize socket listener for command responses and asynchronous + // events + events := make(chan Event) + stream := make(chan streamResponse) + go mon.listen(mon.c, events, stream) + + mon.events = events + mon.stream = stream + + return nil +} + +// Events streams QEMU QMP Events. +// Events should only be called once per Socket. If used with a qemu.Domain, +// qemu.Domain.Events should be called to retrieve events instead. +func (mon *SocketMonitor) Events(context.Context) (<-chan Event, error) { + atomic.AddInt32(mon.listeners, 1) + return mon.events, nil +} + +// listen listens for incoming data from a QEMU monitor socket. It determines +// if the data is an asynchronous event or a response to a command, and returns +// the data on the appropriate channel. +func (mon *SocketMonitor) listen(r io.Reader, events chan<- Event, stream chan<- streamResponse) { + defer close(events) + defer close(stream) + + scanner := bufio.NewScanner(r) + for scanner.Scan() { + var e Event + + b := scanner.Bytes() + if err := json.Unmarshal(b, &e); err != nil { + continue + } + + // If data does not have an event type, it must be in response to a command. + if e.Event == "" { + stream <- streamResponse{buf: b} + continue + } + + // If nobody is listening for events, do not bother sending them. + if atomic.LoadInt32(mon.listeners) == 0 { + continue + } + + events <- e + } + + if err := scanner.Err(); err != nil { + stream <- streamResponse{err: err} + } +} + +// Run executes the given QAPI command against a domain's QEMU instance. +// For a list of available QAPI commands, see: +// http://git.qemu.org/?p=qemu.git;a=blob;f=qapi-schema.json;hb=HEAD +func (mon *SocketMonitor) Run(command []byte) ([]byte, error) { + // Just call RunWithFile with no file + return mon.RunWithFile(command, nil) +} + +// RunWithFile behaves like Run but allows for passing a file through out-of-band data. +func (mon *SocketMonitor) RunWithFile(command []byte, file *os.File) ([]byte, error) { + // Only allow a single command to be run at a time to ensure that responses + // to a command cannot be mixed with responses from another command + mon.mu.Lock() + defer mon.mu.Unlock() + + if file == nil { + // Just send a normal command through. + if _, err := mon.c.Write(command); err != nil { + return nil, err + } + } else { + unixConn, ok := mon.c.(*net.UnixConn) + if !ok { + return nil, fmt.Errorf("RunWithFile only works with unix monitor sockets") + } + + oobSupported := false + for _, capability := range mon.Capabilities { + if capability == "oob" { + oobSupported = true + break + } + } + + if !oobSupported { + return nil, fmt.Errorf("The QEMU server doesn't support oob (needed for RunWithFile)") + } + + // Send the command along with the file descriptor. + oob := getUnixRights(file) + if _, _, err := unixConn.WriteMsgUnix(command, oob, nil); err != nil { + return nil, err + } + } + + // Wait for a response or error to our command + res := <-mon.stream + if res.err != nil { + return nil, res.err + } + + // Check for QEMU errors + var r response + if err := json.Unmarshal(res.buf, &r); err != nil { + return nil, err + } + if err := r.Err(); err != nil { + return nil, err + } + + return res.buf, nil +} + +// banner is a wrapper type around a Version. +type banner struct { + QMP struct { + Capabilities []string `json:"capabilities"` + Version Version `json:"version"` + } `json:"QMP"` +} + +// streamResponse is a struct sent over a channel in response to a command. +type streamResponse struct { + buf []byte + err error +} diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go new file mode 100644 index 000000000..859ff64ea --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket_unix.go @@ -0,0 +1,27 @@ +// Copyright 2016 The go-qemu Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build !windows + +package qmp + +import ( + "os" + + "golang.org/x/sys/unix" +) + +func getUnixRights(file *os.File) []byte { + return unix.UnixRights(int(file.Fd())) +} diff --git a/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go b/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go new file mode 100644 index 000000000..b8a611dbf --- /dev/null +++ b/vendor/github.com/digitalocean/go-qemu/qmp/socket_windows.go @@ -0,0 +1,25 @@ +// Copyright 2016 The go-qemu Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build windows + +package qmp + +import ( + "os" +) + +func getUnixRights(file *os.File) []byte { + return nil +} diff --git a/vendor/github.com/vbauerster/mpb/v6/.gitignore b/vendor/github.com/vbauerster/mpb/v6/.gitignore new file mode 100644 index 000000000..63bd91672 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/.gitignore @@ -0,0 +1,5 @@ +# Test binary, build with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out diff --git a/vendor/github.com/vbauerster/mpb/v6/.travis.yml b/vendor/github.com/vbauerster/mpb/v6/.travis.yml new file mode 100644 index 000000000..9a203a67d --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/.travis.yml @@ -0,0 +1,11 @@ +language: go +arch: + - amd64 + - ppc64le + +go: + - 1.14.x + +script: + - go test -race ./... + - for i in _examples/*/; do go build $i/*.go || exit 1; done diff --git a/vendor/github.com/vbauerster/mpb/v6/README.md b/vendor/github.com/vbauerster/mpb/v6/README.md new file mode 100644 index 000000000..a87786d72 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/README.md @@ -0,0 +1,120 @@ +# Multi Progress Bar + +[](https://pkg.go.dev/github.com/vbauerster/mpb/v6) +[](https://travis-ci.org/vbauerster/mpb) +[](https://goreportcard.com/report/github.com/vbauerster/mpb) + +**mpb** is a Go lib for rendering progress bars in terminal applications. + +## Features + +- **Multiple Bars**: Multiple progress bars are supported +- **Dynamic Total**: Set total while bar is running +- **Dynamic Add/Remove**: Dynamically add or remove bars +- **Cancellation**: Cancel whole rendering process +- **Predefined Decorators**: Elapsed time, [ewma](https://github.com/VividCortex/ewma) based ETA, Percentage, Bytes counter +- **Decorator's width sync**: Synchronized decorator's width among multiple bars + +## Usage + +#### [Rendering single bar](_examples/singleBar/main.go) + +```go +package main + +import ( + "math/rand" + "time" + + "github.com/vbauerster/mpb/v6" + "github.com/vbauerster/mpb/v6/decor" +) + +func main() { + // initialize progress container, with custom width + p := mpb.New(mpb.WithWidth(64)) + + total := 100 + name := "Single Bar:" + // adding a single bar, which will inherit container's width + bar := p.Add(int64(total), + // progress bar filler with customized style + mpb.NewBarFiller("╢▌▌░╟"), + mpb.PrependDecorators( + // display our name with one space on the right + decor.Name(name, decor.WC{W: len(name) + 1, C: decor.DidentRight}), + // replace ETA decorator with "done" message, OnComplete event + decor.OnComplete( + decor.AverageETA(decor.ET_STYLE_GO, decor.WC{W: 4}), "done", + ), + ), + mpb.AppendDecorators(decor.Percentage()), + ) + // simulating some work + max := 100 * time.Millisecond + for i := 0; i < total; i++ { + time.Sleep(time.Duration(rand.Intn(10)+1) * max / 10) + bar.Increment() + } + // wait for our bar to complete and flush + p.Wait() +} +``` + +#### [Rendering multiple bars](_examples/multiBars/main.go) + +```go + var wg sync.WaitGroup + // pass &wg (optional), so p will wait for it eventually + p := mpb.New(mpb.WithWaitGroup(&wg)) + total, numBars := 100, 3 + wg.Add(numBars) + + for i := 0; i < numBars; i++ { + name := fmt.Sprintf("Bar#%d:", i) + bar := p.AddBar(int64(total), + mpb.PrependDecorators( + // simple name decorator + decor.Name(name), + // decor.DSyncWidth bit enables column width synchronization + decor.Percentage(decor.WCSyncSpace), + ), + mpb.AppendDecorators( + // replace ETA decorator with "done" message, OnComplete event + decor.OnComplete( + // ETA decorator with ewma age of 60 + decor.EwmaETA(decor.ET_STYLE_GO, 60), "done", + ), + ), + ) + // simulating some work + go func() { + defer wg.Done() + rng := rand.New(rand.NewSource(time.Now().UnixNano())) + max := 100 * time.Millisecond + for i := 0; i < total; i++ { + // start variable is solely for EWMA calculation + // EWMA's unit of measure is an iteration's duration + start := time.Now() + time.Sleep(time.Duration(rng.Intn(10)+1) * max / 10) + bar.Increment() + // we need to call DecoratorEwmaUpdate to fulfill ewma decorator's contract + bar.DecoratorEwmaUpdate(time.Since(start)) + } + }() + } + // Waiting for passed &wg and for all bars to complete and flush + p.Wait() +``` + +#### [Dynamic total](_examples/dynTotal/main.go) + + + +#### [Complex example](_examples/complex/main.go) + + + +#### [Bytes counters](_examples/io/main.go) + + diff --git a/vendor/github.com/vbauerster/mpb/v6/UNLICENSE b/vendor/github.com/vbauerster/mpb/v6/UNLICENSE new file mode 100644 index 000000000..68a49daad --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/UNLICENSE @@ -0,0 +1,24 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or +distribute this software, either in source code form or as a compiled +binary, for any purpose, commercial or non-commercial, and by any +means. + +In jurisdictions that recognize copyright laws, the author or authors +of this software dedicate any and all copyright interest in the +software to the public domain. We make this dedication for the benefit +of the public at large and to the detriment of our heirs and +successors. We intend this dedication to be an overt act of +relinquishment in perpetuity of all present and future rights to this +software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to <http://unlicense.org/> diff --git a/vendor/github.com/vbauerster/mpb/v6/bar.go b/vendor/github.com/vbauerster/mpb/v6/bar.go new file mode 100644 index 000000000..f18ef967f --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/bar.go @@ -0,0 +1,492 @@ +package mpb + +import ( + "bytes" + "context" + "fmt" + "io" + "log" + "runtime/debug" + "strings" + "time" + + "github.com/acarl005/stripansi" + "github.com/mattn/go-runewidth" + "github.com/vbauerster/mpb/v6/decor" +) + +// Bar represents a progress bar. +type Bar struct { + priority int // used by heap + index int // used by heap + + extendedLines int + toShutdown bool + toDrop bool + noPop bool + hasEwmaDecorators bool + operateState chan func(*bState) + frameCh chan io.Reader + syncTableCh chan [][]chan int + completed chan bool + + // cancel is called either by user or on complete event + cancel func() + // done is closed after cacheState is assigned + done chan struct{} + // cacheState is populated, right after close(shutdown) + cacheState *bState + + container *Progress + dlogger *log.Logger + recoveredPanic interface{} +} + +type extenderFunc func(in io.Reader, reqWidth int, st decor.Statistics) (out io.Reader, lines int) + +// bState is actual bar state. It gets passed to *Bar.serve(...) monitor +// goroutine. +type bState struct { + id int + priority int + reqWidth int + total int64 + current int64 + refill int64 + lastN int64 + iterated bool + trimSpace bool + completed bool + completeFlushed bool + triggerComplete bool + dropOnComplete bool + noPop bool + aDecorators []decor.Decorator + pDecorators []decor.Decorator + averageDecorators []decor.AverageDecorator + ewmaDecorators []decor.EwmaDecorator + shutdownListeners []decor.ShutdownListener + bufP, bufB, bufA *bytes.Buffer + filler BarFiller + middleware func(BarFiller) BarFiller + extender extenderFunc + + // runningBar is a key for *pState.parkedBars + runningBar *Bar + + debugOut io.Writer +} + +func newBar(container *Progress, bs *bState) *Bar { + logPrefix := fmt.Sprintf("%sbar#%02d ", container.dlogger.Prefix(), bs.id) + ctx, cancel := context.WithCancel(container.ctx) + + bar := &Bar{ + container: container, + priority: bs.priority, + toDrop: bs.dropOnComplete, + noPop: bs.noPop, + operateState: make(chan func(*bState)), + frameCh: make(chan io.Reader, 1), + syncTableCh: make(chan [][]chan int, 1), + completed: make(chan bool, 1), + done: make(chan struct{}), + cancel: cancel, + dlogger: log.New(bs.debugOut, logPrefix, log.Lshortfile), + } + + go bar.serve(ctx, bs) + return bar +} + +// ProxyReader wraps r with metrics required for progress tracking. +// Panics if r is nil. +func (b *Bar) ProxyReader(r io.Reader) io.ReadCloser { + if r == nil { + panic("expected non nil io.Reader") + } + return newProxyReader(r, b) +} + +// ID returs id of the bar. +func (b *Bar) ID() int { + result := make(chan int) + select { + case b.operateState <- func(s *bState) { result <- s.id }: + return <-result + case <-b.done: + return b.cacheState.id + } +} + +// Current returns bar's current number, in other words sum of all increments. +func (b *Bar) Current() int64 { + result := make(chan int64) + select { + case b.operateState <- func(s *bState) { result <- s.current }: + return <-result + case <-b.done: + return b.cacheState.current + } +} + +// SetRefill sets refill flag with specified amount. +// The underlying BarFiller will change its visual representation, to +// indicate refill event. Refill event may be referred to some retry +// operation for example. +func (b *Bar) SetRefill(amount int64) { + select { + case b.operateState <- func(s *bState) { + s.refill = amount + }: + case <-b.done: + } +} + +// TraverseDecorators traverses all available decorators and calls cb func on each. +func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) { + select { + case b.operateState <- func(s *bState) { + for _, decorators := range [...][]decor.Decorator{ + s.pDecorators, + s.aDecorators, + } { + for _, d := range decorators { + cb(extractBaseDecorator(d)) + } + } + }: + case <-b.done: + } +} + +// SetTotal sets total dynamically. +// If total is less than or equal to zero it takes progress' current value. +func (b *Bar) SetTotal(total int64, triggerComplete bool) { + select { + case b.operateState <- func(s *bState) { + s.triggerComplete = triggerComplete + if total <= 0 { + s.total = s.current + } else { + s.total = total + } + if s.triggerComplete && !s.completed { + s.current = s.total + s.completed = true + go b.refreshTillShutdown() + } + }: + case <-b.done: + } +} + +// SetCurrent sets progress' current to an arbitrary value. +// Setting a negative value will cause a panic. +func (b *Bar) SetCurrent(current int64) { + select { + case b.operateState <- func(s *bState) { + s.iterated = true + s.lastN = current - s.current + s.current = current + if s.triggerComplete && s.current >= s.total { + s.current = s.total + s.completed = true + go b.refreshTillShutdown() + } + }: + case <-b.done: + } +} + +// Increment is a shorthand for b.IncrInt64(1). +func (b *Bar) Increment() { + b.IncrInt64(1) +} + +// IncrBy is a shorthand for b.IncrInt64(int64(n)). +func (b *Bar) IncrBy(n int) { + b.IncrInt64(int64(n)) +} + +// IncrInt64 increments progress by amount of n. +func (b *Bar) IncrInt64(n int64) { + select { + case b.operateState <- func(s *bState) { + s.iterated = true + s.lastN = n + s.current += n + if s.triggerComplete && s.current >= s.total { + s.current = s.total + s.completed = true + go b.refreshTillShutdown() + } + }: + case <-b.done: + } +} + +// DecoratorEwmaUpdate updates all EWMA based decorators. Should be +// called on each iteration, because EWMA's unit of measure is an +// iteration's duration. Panics if called before *Bar.Incr... family +// methods. +func (b *Bar) DecoratorEwmaUpdate(dur time.Duration) { + select { + case b.operateState <- func(s *bState) { + ewmaIterationUpdate(false, s, dur) + }: + case <-b.done: + ewmaIterationUpdate(true, b.cacheState, dur) + } +} + +// DecoratorAverageAdjust adjusts all average based decorators. Call +// if you need to adjust start time of all average based decorators +// or after progress resume. +func (b *Bar) DecoratorAverageAdjust(start time.Time) { + select { + case b.operateState <- func(s *bState) { + for _, d := range s.averageDecorators { + d.AverageAdjust(start) + } + }: + case <-b.done: + } +} + +// SetPriority changes bar's order among multiple bars. Zero is highest +// priority, i.e. bar will be on top. If you don't need to set priority +// dynamically, better use BarPriority option. +func (b *Bar) SetPriority(priority int) { + select { + case <-b.done: + default: + b.container.setBarPriority(b, priority) + } +} + +// Abort interrupts bar's running goroutine. Call this, if you'd like +// to stop/remove bar before completion event. It has no effect after +// completion event. If drop is true bar will be removed as well. +func (b *Bar) Abort(drop bool) { + select { + case <-b.done: + default: + if drop { + b.container.dropBar(b) + } + b.cancel() + } +} + +// Completed reports whether the bar is in completed state. +func (b *Bar) Completed() bool { + select { + case b.operateState <- func(s *bState) { b.completed <- s.completed }: + return <-b.completed + case <-b.done: + return true + } +} + +func (b *Bar) serve(ctx context.Context, s *bState) { + defer b.container.bwg.Done() + for { + select { + case op := <-b.operateState: + op(s) + case <-ctx.Done(): + b.cacheState = s + close(b.done) + // Notifying decorators about shutdown event + for _, sl := range s.shutdownListeners { + sl.Shutdown() + } + return + } + } +} + +func (b *Bar) render(tw int) { + select { + case b.operateState <- func(s *bState) { + stat := newStatistics(tw, s) + defer func() { + // recovering if user defined decorator panics for example + if p := recover(); p != nil { + if b.recoveredPanic == nil { + s.extender = makePanicExtender(p) + b.toShutdown = !b.toShutdown + b.recoveredPanic = p + } + frame, lines := s.extender(nil, s.reqWidth, stat) + b.extendedLines = lines + b.frameCh <- frame + b.dlogger.Println(p) + } + s.completeFlushed = s.completed + }() + frame, lines := s.extender(s.draw(stat), s.reqWidth, stat) + b.extendedLines = lines + b.toShutdown = s.completed && !s.completeFlushed + b.frameCh <- frame + }: + case <-b.done: + s := b.cacheState + stat := newStatistics(tw, s) + var r io.Reader + if b.recoveredPanic == nil { + r = s.draw(stat) + } + frame, lines := s.extender(r, s.reqWidth, stat) + b.extendedLines = lines + b.frameCh <- frame + } +} + +func (b *Bar) subscribeDecorators() { + var averageDecorators []decor.AverageDecorator + var ewmaDecorators []decor.EwmaDecorator + var shutdownListeners []decor.ShutdownListener + b.TraverseDecorators(func(d decor.Decorator) { + if d, ok := d.(decor.AverageDecorator); ok { + averageDecorators = append(averageDecorators, d) + } + if d, ok := d.(decor.EwmaDecorator); ok { + ewmaDecorators = append(ewmaDecorators, d) + } + if d, ok := d.(decor.ShutdownListener); ok { + shutdownListeners = append(shutdownListeners, d) + } + }) + select { + case b.operateState <- func(s *bState) { + s.averageDecorators = averageDecorators + s.ewmaDecorators = ewmaDecorators + s.shutdownListeners = shutdownListeners + }: + b.hasEwmaDecorators = len(ewmaDecorators) != 0 + case <-b.done: + } +} + +func (b *Bar) refreshTillShutdown() { + for { + select { + case b.container.refreshCh <- time.Now(): + case <-b.done: + return + } + } +} + +func (b *Bar) wSyncTable() [][]chan int { + select { + case b.operateState <- func(s *bState) { b.syncTableCh <- s.wSyncTable() }: + return <-b.syncTableCh + case <-b.done: + return b.cacheState.wSyncTable() + } +} + +func (s *bState) draw(stat decor.Statistics) io.Reader { + if !s.trimSpace { + stat.AvailableWidth -= 2 + s.bufB.WriteByte(' ') + defer s.bufB.WriteByte(' ') + } + + nlr := strings.NewReader("\n") + tw := stat.AvailableWidth + for _, d := range s.pDecorators { + str := d.Decor(stat) + stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str)) + s.bufP.WriteString(str) + } + if stat.AvailableWidth <= 0 { + trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufP.String()), tw, "…")) + s.bufP.Reset() + return io.MultiReader(trunc, s.bufB, nlr) + } + + tw = stat.AvailableWidth + for _, d := range s.aDecorators { + str := d.Decor(stat) + stat.AvailableWidth -= runewidth.StringWidth(stripansi.Strip(str)) + s.bufA.WriteString(str) + } + if stat.AvailableWidth <= 0 { + trunc := strings.NewReader(runewidth.Truncate(stripansi.Strip(s.bufA.String()), tw, "…")) + s.bufA.Reset() + return io.MultiReader(s.bufP, s.bufB, trunc, nlr) + } + + s.filler.Fill(s.bufB, s.reqWidth, stat) + + return io.MultiReader(s.bufP, s.bufB, s.bufA, nlr) +} + +func (s *bState) wSyncTable() [][]chan int { + columns := make([]chan int, 0, len(s.pDecorators)+len(s.aDecorators)) + var pCount int + for _, d := range s.pDecorators { + if ch, ok := d.Sync(); ok { + columns = append(columns, ch) + pCount++ + } + } + var aCount int + for _, d := range s.aDecorators { + if ch, ok := d.Sync(); ok { + columns = append(columns, ch) + aCount++ + } + } + table := make([][]chan int, 2) + table[0] = columns[0:pCount] + table[1] = columns[pCount : pCount+aCount : pCount+aCount] + return table +} + +func newStatistics(tw int, s *bState) decor.Statistics { + return decor.Statistics{ + ID: s.id, + AvailableWidth: tw, + Total: s.total, + Current: s.current, + Refill: s.refill, + Completed: s.completeFlushed, + } +} + +func extractBaseDecorator(d decor.Decorator) decor.Decorator { + if d, ok := d.(decor.Wrapper); ok { + return extractBaseDecorator(d.Base()) + } + return d +} + +func ewmaIterationUpdate(done bool, s *bState, dur time.Duration) { + if !done && !s.iterated { + panic("increment required before ewma iteration update") + } else { + s.iterated = false + } + for _, d := range s.ewmaDecorators { + d.EwmaUpdate(s.lastN, dur) + } +} + +func makePanicExtender(p interface{}) extenderFunc { + pstr := fmt.Sprint(p) + stack := debug.Stack() + stackLines := bytes.Count(stack, []byte("\n")) + return func(_ io.Reader, _ int, st decor.Statistics) (io.Reader, int) { + mr := io.MultiReader( + strings.NewReader(runewidth.Truncate(pstr, st.AvailableWidth, "…")), + strings.NewReader(fmt.Sprintf("\n%#v\n", st)), + bytes.NewReader(stack), + ) + return mr, stackLines + 1 + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler.go new file mode 100644 index 000000000..c8cedaa4a --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler.go @@ -0,0 +1,31 @@ +package mpb + +import ( + "io" + + "github.com/vbauerster/mpb/v6/decor" +) + +// BarFiller interface. +// Bar (without decorators) renders itself by calling BarFiller's Fill method. +// +// reqWidth is requested width, set by `func WithWidth(int) ContainerOption`. +// If not set, it defaults to terminal width. +// +// Default implementations can be obtained via: +// +// func NewBarFiller(style string) BarFiller +// func NewBarFillerRev(style string) BarFiller +// func NewBarFillerPick(style string, rev bool) BarFiller +// func NewSpinnerFiller(style []string, alignment SpinnerAlignment) BarFiller +// +type BarFiller interface { + Fill(w io.Writer, reqWidth int, stat decor.Statistics) +} + +// BarFillerFunc is function type adapter to convert function into BarFiller. +type BarFillerFunc func(w io.Writer, reqWidth int, stat decor.Statistics) + +func (f BarFillerFunc) Fill(w io.Writer, reqWidth int, stat decor.Statistics) { + f(w, reqWidth, stat) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go new file mode 100644 index 000000000..50494485e --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler_bar.go @@ -0,0 +1,191 @@ +package mpb + +import ( + "bytes" + "io" + "unicode/utf8" + + "github.com/mattn/go-runewidth" + "github.com/rivo/uniseg" + "github.com/vbauerster/mpb/v6/decor" + "github.com/vbauerster/mpb/v6/internal" +) + +const ( + rLeft = iota + rFill + rTip + rSpace + rRight + rRevTip + rRefill +) + +// BarDefaultStyle is a style for rendering a progress bar. +// It consist of 7 ordered runes: +// +// '1st rune' stands for left boundary rune +// +// '2nd rune' stands for fill rune +// +// '3rd rune' stands for tip rune +// +// '4th rune' stands for space rune +// +// '5th rune' stands for right boundary rune +// +// '6th rune' stands for reverse tip rune +// +// '7th rune' stands for refill rune +// +const BarDefaultStyle string = "[=>-]<+" + +type barFiller struct { + format [][]byte + rwidth []int + tip []byte + refill int64 + reverse bool + flush func(io.Writer, *space, [][]byte) +} + +type space struct { + space []byte + rwidth int + count int +} + +// NewBarFiller returns a BarFiller implementation which renders a +// progress bar in regular direction. If style is empty string, +// BarDefaultStyle is applied. To be used with `*Progress.Add(...) +// *Bar` method. +func NewBarFiller(style string) BarFiller { + return newBarFiller(style, false) +} + +// NewBarFillerRev returns a BarFiller implementation which renders a +// progress bar in reverse direction. If style is empty string, +// BarDefaultStyle is applied. To be used with `*Progress.Add(...) +// *Bar` method. +func NewBarFillerRev(style string) BarFiller { + return newBarFiller(style, true) +} + +// NewBarFillerPick pick between regular and reverse BarFiller implementation +// based on rev param. To be used with `*Progress.Add(...) *Bar` method. +func NewBarFillerPick(style string, rev bool) BarFiller { + return newBarFiller(style, rev) +} + +func newBarFiller(style string, rev bool) BarFiller { + bf := &barFiller{ + format: make([][]byte, len(BarDefaultStyle)), + rwidth: make([]int, len(BarDefaultStyle)), + reverse: rev, + } + bf.parse(BarDefaultStyle) + if style != "" && style != BarDefaultStyle { + bf.parse(style) + } + return bf +} + +func (s *barFiller) parse(style string) { + if !utf8.ValidString(style) { + panic("invalid bar style") + } + srcFormat := make([][]byte, 0, len(BarDefaultStyle)) + srcRwidth := make([]int, 0, len(BarDefaultStyle)) + gr := uniseg.NewGraphemes(style) + for gr.Next() { + srcFormat = append(srcFormat, gr.Bytes()) + srcRwidth = append(srcRwidth, runewidth.StringWidth(gr.Str())) + } + copy(s.format, srcFormat) + copy(s.rwidth, srcRwidth) + if s.reverse { + s.tip = s.format[rRevTip] + s.flush = reverseFlush + } else { + s.tip = s.format[rTip] + s.flush = regularFlush + } +} + +func (s *barFiller) Fill(w io.Writer, reqWidth int, stat decor.Statistics) { + width := internal.CheckRequestedWidth(reqWidth, stat.AvailableWidth) + brackets := s.rwidth[rLeft] + s.rwidth[rRight] + if width < brackets { + return + } + // don't count brackets as progress + width -= brackets + + w.Write(s.format[rLeft]) + defer w.Write(s.format[rRight]) + + cwidth := int(internal.PercentageRound(stat.Total, stat.Current, width)) + space := &space{ + space: s.format[rSpace], + rwidth: s.rwidth[rSpace], + count: width - cwidth, + } + + index, refill := 0, 0 + bb := make([][]byte, cwidth) + + if cwidth > 0 && cwidth != width { + bb[index] = s.tip + cwidth -= s.rwidth[rTip] + index++ + } + + if stat.Refill > 0 { + refill = int(internal.PercentageRound(stat.Total, int64(stat.Refill), width)) + if refill > cwidth { + refill = cwidth + } + cwidth -= refill + } + + for cwidth > 0 { + bb[index] = s.format[rFill] + cwidth -= s.rwidth[rFill] + index++ + } + + for refill > 0 { + bb[index] = s.format[rRefill] + refill -= s.rwidth[rRefill] + index++ + } + + if cwidth+refill < 0 || space.rwidth > 1 { + buf := new(bytes.Buffer) + s.flush(buf, space, bb[:index]) + io.WriteString(w, runewidth.Truncate(buf.String(), width, "…")) + return + } + + s.flush(w, space, bb) +} + +func regularFlush(w io.Writer, space *space, bb [][]byte) { + for i := len(bb) - 1; i >= 0; i-- { + w.Write(bb[i]) + } + for space.count > 0 { + w.Write(space.space) + space.count -= space.rwidth + } +} + +func reverseFlush(w io.Writer, space *space, bb [][]byte) { + for space.count > 0 { + w.Write(space.space) + space.count -= space.rwidth + } + for i := 0; i < len(bb); i++ { + w.Write(bb[i]) + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go b/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go new file mode 100644 index 000000000..0817b19ec --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/bar_filler_spinner.go @@ -0,0 +1,65 @@ +package mpb + +import ( + "io" + "strings" + + "github.com/mattn/go-runewidth" + "github.com/vbauerster/mpb/v6/decor" + "github.com/vbauerster/mpb/v6/internal" +) + +// SpinnerAlignment enum. +type SpinnerAlignment int + +// SpinnerAlignment kinds. +const ( + SpinnerOnLeft SpinnerAlignment = iota + SpinnerOnMiddle + SpinnerOnRight +) + +// SpinnerDefaultStyle is a style for rendering a spinner. +var SpinnerDefaultStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"} + +type spinnerFiller struct { + frames []string + count uint + alignment SpinnerAlignment +} + +// NewSpinnerFiller returns a BarFiller implementation which renders +// a spinner. If style is nil or zero length, SpinnerDefaultStyle is +// applied. To be used with `*Progress.Add(...) *Bar` method. +func NewSpinnerFiller(style []string, alignment SpinnerAlignment) BarFiller { + if len(style) == 0 { + style = SpinnerDefaultStyle + } + filler := &spinnerFiller{ + frames: style, + alignment: alignment, + } + return filler +} + +func (s *spinnerFiller) Fill(w io.Writer, reqWidth int, stat decor.Statistics) { + width := internal.CheckRequestedWidth(reqWidth, stat.AvailableWidth) + + frame := s.frames[s.count%uint(len(s.frames))] + frameWidth := runewidth.StringWidth(frame) + + if width < frameWidth { + return + } + + switch rest := width - frameWidth; s.alignment { + case SpinnerOnLeft: + io.WriteString(w, frame+strings.Repeat(" ", rest)) + case SpinnerOnMiddle: + str := strings.Repeat(" ", rest/2) + frame + strings.Repeat(" ", rest/2+rest%2) + io.WriteString(w, str) + case SpinnerOnRight: + io.WriteString(w, strings.Repeat(" ", rest)+frame) + } + s.count++ +} diff --git a/vendor/github.com/vbauerster/mpb/v6/bar_option.go b/vendor/github.com/vbauerster/mpb/v6/bar_option.go new file mode 100644 index 000000000..e359c110c --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/bar_option.go @@ -0,0 +1,153 @@ +package mpb + +import ( + "bytes" + "io" + + "github.com/vbauerster/mpb/v6/decor" + "github.com/vbauerster/mpb/v6/internal" +) + +// BarOption is a func option to alter default behavior of a bar. +type BarOption func(*bState) + +func (s *bState) addDecorators(dest *[]decor.Decorator, decorators ...decor.Decorator) { + type mergeWrapper interface { + MergeUnwrap() []decor.Decorator + } + for _, decorator := range decorators { + if mw, ok := decorator.(mergeWrapper); ok { + *dest = append(*dest, mw.MergeUnwrap()...) + } + *dest = append(*dest, decorator) + } +} + +// AppendDecorators let you inject decorators to the bar's right side. +func AppendDecorators(decorators ...decor.Decorator) BarOption { + return func(s *bState) { + s.addDecorators(&s.aDecorators, decorators...) + } +} + +// PrependDecorators let you inject decorators to the bar's left side. +func PrependDecorators(decorators ...decor.Decorator) BarOption { + return func(s *bState) { + s.addDecorators(&s.pDecorators, decorators...) + } +} + +// BarID sets bar id. +func BarID(id int) BarOption { + return func(s *bState) { + s.id = id + } +} + +// BarWidth sets bar width independent of the container. +func BarWidth(width int) BarOption { + return func(s *bState) { + s.reqWidth = width + } +} + +// BarQueueAfter queues this (being constructed) bar to relplace +// runningBar after it has been completed. +func BarQueueAfter(runningBar *Bar) BarOption { + if runningBar == nil { + return nil + } + return func(s *bState) { + s.runningBar = runningBar + } +} + +// BarRemoveOnComplete removes both bar's filler and its decorators +// on complete event. +func BarRemoveOnComplete() BarOption { + return func(s *bState) { + s.dropOnComplete = true + } +} + +// BarFillerClearOnComplete clears bar's filler on complete event. +// It's shortcut for BarFillerOnComplete(""). +func BarFillerClearOnComplete() BarOption { + return BarFillerOnComplete("") +} + +// BarFillerOnComplete replaces bar's filler with message, on complete event. +func BarFillerOnComplete(message string) BarOption { + return BarFillerMiddleware(func(base BarFiller) BarFiller { + return BarFillerFunc(func(w io.Writer, reqWidth int, st decor.Statistics) { + if st.Completed { + io.WriteString(w, message) + } else { + base.Fill(w, reqWidth, st) + } + }) + }) +} + +// BarFillerMiddleware provides a way to augment the underlying BarFiller. +func BarFillerMiddleware(middle func(BarFiller) BarFiller) BarOption { + return func(s *bState) { + s.middleware = middle + } +} + +// BarPriority sets bar's priority. Zero is highest priority, i.e. bar +// will be on top. If `BarReplaceOnComplete` option is supplied, this +// option is ignored. +func BarPriority(priority int) BarOption { + return func(s *bState) { + s.priority = priority + } +} + +// BarExtender provides a way to extend bar to the next new line. +func BarExtender(filler BarFiller) BarOption { + if filler == nil { + return nil + } + return func(s *bState) { + s.extender = makeExtenderFunc(filler) + } +} + +func makeExtenderFunc(filler BarFiller) extenderFunc { + buf := new(bytes.Buffer) + return func(r io.Reader, reqWidth int, st decor.Statistics) (io.Reader, int) { + filler.Fill(buf, reqWidth, st) + return io.MultiReader(r, buf), bytes.Count(buf.Bytes(), []byte("\n")) + } +} + +// BarFillerTrim removes leading and trailing space around the underlying BarFiller. +func BarFillerTrim() BarOption { + return func(s *bState) { + s.trimSpace = true + } +} + +// BarNoPop disables bar pop out of container. Effective when +// PopCompletedMode of container is enabled. +func BarNoPop() BarOption { + return func(s *bState) { + s.noPop = true + } +} + +// BarOptional will invoke provided option only when pick is true. +func BarOptional(option BarOption, pick bool) BarOption { + return BarOptOn(option, internal.Predicate(pick)) +} + +// BarOptOn will invoke provided option only when higher order predicate +// evaluates to true. +func BarOptOn(option BarOption, predicate func() bool) BarOption { + if predicate() { + return option + } + return nil +} diff --git a/vendor/github.com/vbauerster/mpb/v6/container_option.go b/vendor/github.com/vbauerster/mpb/v6/container_option.go new file mode 100644 index 000000000..b92c7578c --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/container_option.go @@ -0,0 +1,112 @@ +package mpb + +import ( + "io" + "io/ioutil" + "sync" + "time" + + "github.com/vbauerster/mpb/v6/internal" +) + +// ContainerOption is a func option to alter default behavior of a bar +// container. Container term refers to a Progress struct which can +// hold one or more Bars. +type ContainerOption func(*pState) + +// WithWaitGroup provides means to have a single joint point. If +// *sync.WaitGroup is provided, you can safely call just p.Wait() +// without calling Wait() on provided *sync.WaitGroup. Makes sense +// when there are more than one bar to render. +func WithWaitGroup(wg *sync.WaitGroup) ContainerOption { + return func(s *pState) { + s.uwg = wg + } +} + +// WithWidth sets container width. If not set it defaults to terminal +// width. A bar added to the container will inherit its width, unless +// overridden by `func BarWidth(int) BarOption`. +func WithWidth(width int) ContainerOption { + return func(s *pState) { + s.reqWidth = width + } +} + +// WithRefreshRate overrides default 120ms refresh rate. +func WithRefreshRate(d time.Duration) ContainerOption { + return func(s *pState) { + s.rr = d + } +} + +// WithManualRefresh disables internal auto refresh time.Ticker. +// Refresh will occur upon receive value from provided ch. +func WithManualRefresh(ch <-chan interface{}) ContainerOption { + return func(s *pState) { + s.externalRefresh = ch + } +} + +// WithRenderDelay delays rendering. By default rendering starts as +// soon as bar is added, with this option it's possible to delay +// rendering process by keeping provided chan unclosed. In other words +// rendering will start as soon as provided chan is closed. +func WithRenderDelay(ch <-chan struct{}) ContainerOption { + return func(s *pState) { + s.renderDelay = ch + } +} + +// WithShutdownNotifier provided chanel will be closed, after all bars +// have been rendered. +func WithShutdownNotifier(ch chan struct{}) ContainerOption { + return func(s *pState) { + s.shutdownNotifier = ch + } +} + +// WithOutput overrides default os.Stdout output. Setting it to nil +// will effectively disable auto refresh rate and discard any output, +// useful if you want to disable progress bars with little overhead. +func WithOutput(w io.Writer) ContainerOption { + return func(s *pState) { + if w == nil { + s.output = ioutil.Discard + s.outputDiscarded = true + return + } + s.output = w + } +} + +// WithDebugOutput sets debug output. +func WithDebugOutput(w io.Writer) ContainerOption { + if w == nil { + return nil + } + return func(s *pState) { + s.debugOut = w + } +} + +// PopCompletedMode will pop and stop rendering completed bars. +func PopCompletedMode() ContainerOption { + return func(s *pState) { + s.popCompleted = true + } +} + +// ContainerOptional will invoke provided option only when pick is true. +func ContainerOptional(option ContainerOption, pick bool) ContainerOption { + return ContainerOptOn(option, internal.Predicate(pick)) +} + +// ContainerOptOn will invoke provided option only when higher order +// predicate evaluates to true. +func ContainerOptOn(option ContainerOption, predicate func() bool) ContainerOption { + if predicate() { + return option + } + return nil +} diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go new file mode 100644 index 000000000..93c8f8268 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/doc.go @@ -0,0 +1,2 @@ +// Package cwriter is a console writer abstraction for the underlying OS. +package cwriter diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go new file mode 100644 index 000000000..4e3564ece --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_bsd.go @@ -0,0 +1,7 @@ +// +build darwin dragonfly freebsd netbsd openbsd + +package cwriter + +import "golang.org/x/sys/unix" + +const ioctlReadTermios = unix.TIOCGETA diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go new file mode 100644 index 000000000..253f12dd2 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_linux.go @@ -0,0 +1,7 @@ +// +build aix linux + +package cwriter + +import "golang.org/x/sys/unix" + +const ioctlReadTermios = unix.TCGETS diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go new file mode 100644 index 000000000..4b29ff5c0 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/util_solaris.go @@ -0,0 +1,7 @@ +// +build solaris + +package cwriter + +import "golang.org/x/sys/unix" + +const ioctlReadTermios = unix.TCGETA diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go new file mode 100644 index 000000000..1ade54761 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer.go @@ -0,0 +1,84 @@ +package cwriter + +import ( + "bytes" + "errors" + "io" + "os" + "strconv" +) + +// ErrNotTTY not a TeleTYpewriter error. +var ErrNotTTY = errors.New("not a terminal") + +// http://ascii-table.com/ansi-escape-sequences.php +const ( + escOpen = "\x1b[" + cuuAndEd = "A\x1b[J" +) + +// Writer is a buffered the writer that updates the terminal. The +// contents of writer will be flushed when Flush is called. +type Writer struct { + out io.Writer + buf bytes.Buffer + lineCount int + fd int + isTerminal bool +} + +// New returns a new Writer with defaults. +func New(out io.Writer) *Writer { + w := &Writer{out: out} + if f, ok := out.(*os.File); ok { + w.fd = int(f.Fd()) + w.isTerminal = IsTerminal(w.fd) + } + return w +} + +// Flush flushes the underlying buffer. +func (w *Writer) Flush(lineCount int) (err error) { + // some terminals interpret 'cursor up 0' as 'cursor up 1' + if w.lineCount > 0 { + err = w.clearLines() + if err != nil { + return + } + } + w.lineCount = lineCount + _, err = w.buf.WriteTo(w.out) + return +} + +// Write appends the contents of p to the underlying buffer. +func (w *Writer) Write(p []byte) (n int, err error) { + return w.buf.Write(p) +} + +// WriteString writes string to the underlying buffer. +func (w *Writer) WriteString(s string) (n int, err error) { + return w.buf.WriteString(s) +} + +// ReadFrom reads from the provided io.Reader and writes to the +// underlying buffer. +func (w *Writer) ReadFrom(r io.Reader) (n int64, err error) { + return w.buf.ReadFrom(r) +} + +// GetWidth returns width of underlying terminal. +func (w *Writer) GetWidth() (int, error) { + if !w.isTerminal { + return -1, ErrNotTTY + } + tw, _, err := GetSize(w.fd) + return tw, err +} + +func (w *Writer) ansiCuuAndEd() (err error) { + buf := make([]byte, 8) + buf = strconv.AppendInt(buf[:copy(buf, escOpen)], int64(w.lineCount), 10) + _, err = w.out.Write(append(buf, cuuAndEd...)) + return +} diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go new file mode 100644 index 000000000..f54a5d06b --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_posix.go @@ -0,0 +1,26 @@ +// +build !windows + +package cwriter + +import ( + "golang.org/x/sys/unix" +) + +func (w *Writer) clearLines() error { + return w.ansiCuuAndEd() +} + +// GetSize returns the dimensions of the given terminal. +func GetSize(fd int) (width, height int, err error) { + ws, err := unix.IoctlGetWinsize(fd, unix.TIOCGWINSZ) + if err != nil { + return -1, -1, err + } + return int(ws.Col), int(ws.Row), nil +} + +// IsTerminal returns whether the given file descriptor is a terminal. +func IsTerminal(fd int) bool { + _, err := unix.IoctlGetTermios(fd, ioctlReadTermios) + return err == nil +} diff --git a/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go new file mode 100644 index 000000000..1a69c81ac --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/cwriter/writer_windows.go @@ -0,0 +1,73 @@ +// +build windows + +package cwriter + +import ( + "unsafe" + + "golang.org/x/sys/windows" +) + +var kernel32 = windows.NewLazySystemDLL("kernel32.dll") + +var ( + procSetConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition") + procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW") +) + +func (w *Writer) clearLines() error { + if !w.isTerminal { + // hope it's cygwin or similar + return w.ansiCuuAndEd() + } + + var info windows.ConsoleScreenBufferInfo + if err := windows.GetConsoleScreenBufferInfo(windows.Handle(w.fd), &info); err != nil { + return err + } + + info.CursorPosition.Y -= int16(w.lineCount) + if info.CursorPosition.Y < 0 { + info.CursorPosition.Y = 0 + } + _, _, _ = procSetConsoleCursorPosition.Call( + uintptr(w.fd), + uintptr(uint32(uint16(info.CursorPosition.Y))<<16|uint32(uint16(info.CursorPosition.X))), + ) + + // clear the lines + cursor := &windows.Coord{ + X: info.Window.Left, + Y: info.CursorPosition.Y, + } + count := uint32(info.Size.X) * uint32(w.lineCount) + _, _, _ = procFillConsoleOutputCharacter.Call( + uintptr(w.fd), + uintptr(' '), + uintptr(count), + *(*uintptr)(unsafe.Pointer(cursor)), + uintptr(unsafe.Pointer(new(uint32))), + ) + return nil +} + +// GetSize returns the visible dimensions of the given terminal. +// +// These dimensions don't include any scrollback buffer height. +func GetSize(fd int) (width, height int, err error) { + var info windows.ConsoleScreenBufferInfo + if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &info); err != nil { + return 0, 0, err + } + // terminal.GetSize from crypto/ssh adds "+ 1" to both width and height: + // https://go.googlesource.com/crypto/+/refs/heads/release-branch.go1.14/ssh/terminal/util_windows.go#75 + // but looks like this is a root cause of issue #66, so removing both "+ 1" have fixed it. + return int(info.Window.Right - info.Window.Left), int(info.Window.Bottom - info.Window.Top), nil +} + +// IsTerminal returns whether the given file descriptor is a terminal. +func IsTerminal(fd int) bool { + var st uint32 + err := windows.GetConsoleMode(windows.Handle(fd), &st) + return err == nil +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/any.go b/vendor/github.com/vbauerster/mpb/v6/decor/any.go new file mode 100644 index 000000000..39518f594 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/any.go @@ -0,0 +1,21 @@ +package decor + +// Any decorator displays text, that can be changed during decorator's +// lifetime via provided DecorFunc. +// +// `fn` DecorFunc callback +// +// `wcc` optional WC config +// +func Any(fn DecorFunc, wcc ...WC) Decorator { + return &any{initWC(wcc...), fn} +} + +type any struct { + WC + fn DecorFunc +} + +func (d *any) Decor(s Statistics) string { + return d.FormatMsg(d.fn(s)) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/counters.go b/vendor/github.com/vbauerster/mpb/v6/decor/counters.go new file mode 100644 index 000000000..4a5343d41 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/counters.go @@ -0,0 +1,243 @@ +package decor + +import ( + "fmt" + "strings" +) + +const ( + _ = iota + UnitKiB + UnitKB +) + +// CountersNoUnit is a wrapper around Counters with no unit param. +func CountersNoUnit(pairFmt string, wcc ...WC) Decorator { + return Counters(0, pairFmt, wcc...) +} + +// CountersKibiByte is a wrapper around Counters with predefined unit +// UnitKiB (bytes/1024). +func CountersKibiByte(pairFmt string, wcc ...WC) Decorator { + return Counters(UnitKiB, pairFmt, wcc...) +} + +// CountersKiloByte is a wrapper around Counters with predefined unit +// UnitKB (bytes/1000). +func CountersKiloByte(pairFmt string, wcc ...WC) Decorator { + return Counters(UnitKB, pairFmt, wcc...) +} + +// Counters decorator with dynamic unit measure adjustment. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `pairFmt` printf compatible verbs for current and total pair +// +// `wcc` optional WC config +// +// pairFmt example if unit=UnitKB: +// +// pairFmt="%.1f / %.1f" output: "1.0MB / 12.0MB" +// pairFmt="% .1f / % .1f" output: "1.0 MB / 12.0 MB" +// pairFmt="%d / %d" output: "1MB / 12MB" +// pairFmt="% d / % d" output: "1 MB / 12 MB" +// +func Counters(unit int, pairFmt string, wcc ...WC) Decorator { + producer := func(unit int, pairFmt string) DecorFunc { + if pairFmt == "" { + pairFmt = "%d / %d" + } else if strings.Count(pairFmt, "%") != 2 { + panic("expected pairFmt with exactly 2 verbs") + } + switch unit { + case UnitKiB: + return func(s Statistics) string { + return fmt.Sprintf(pairFmt, SizeB1024(s.Current), SizeB1024(s.Total)) + } + case UnitKB: + return func(s Statistics) string { + return fmt.Sprintf(pairFmt, SizeB1000(s.Current), SizeB1000(s.Total)) + } + default: + return func(s Statistics) string { + return fmt.Sprintf(pairFmt, s.Current, s.Total) + } + } + } + return Any(producer(unit, pairFmt), wcc...) +} + +// TotalNoUnit is a wrapper around Total with no unit param. +func TotalNoUnit(format string, wcc ...WC) Decorator { + return Total(0, format, wcc...) +} + +// TotalKibiByte is a wrapper around Total with predefined unit +// UnitKiB (bytes/1024). +func TotalKibiByte(format string, wcc ...WC) Decorator { + return Total(UnitKiB, format, wcc...) +} + +// TotalKiloByte is a wrapper around Total with predefined unit +// UnitKB (bytes/1000). +func TotalKiloByte(format string, wcc ...WC) Decorator { + return Total(UnitKB, format, wcc...) +} + +// Total decorator with dynamic unit measure adjustment. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `format` printf compatible verb for Total +// +// `wcc` optional WC config +// +// format example if unit=UnitKiB: +// +// format="%.1f" output: "12.0MiB" +// format="% .1f" output: "12.0 MiB" +// format="%d" output: "12MiB" +// format="% d" output: "12 MiB" +// +func Total(unit int, format string, wcc ...WC) Decorator { + producer := func(unit int, format string) DecorFunc { + if format == "" { + format = "%d" + } else if strings.Count(format, "%") != 1 { + panic("expected format with exactly 1 verb") + } + + switch unit { + case UnitKiB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1024(s.Total)) + } + case UnitKB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1000(s.Total)) + } + default: + return func(s Statistics) string { + return fmt.Sprintf(format, s.Total) + } + } + } + return Any(producer(unit, format), wcc...) +} + +// CurrentNoUnit is a wrapper around Current with no unit param. +func CurrentNoUnit(format string, wcc ...WC) Decorator { + return Current(0, format, wcc...) +} + +// CurrentKibiByte is a wrapper around Current with predefined unit +// UnitKiB (bytes/1024). +func CurrentKibiByte(format string, wcc ...WC) Decorator { + return Current(UnitKiB, format, wcc...) +} + +// CurrentKiloByte is a wrapper around Current with predefined unit +// UnitKB (bytes/1000). +func CurrentKiloByte(format string, wcc ...WC) Decorator { + return Current(UnitKB, format, wcc...) +} + +// Current decorator with dynamic unit measure adjustment. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `format` printf compatible verb for Current +// +// `wcc` optional WC config +// +// format example if unit=UnitKiB: +// +// format="%.1f" output: "12.0MiB" +// format="% .1f" output: "12.0 MiB" +// format="%d" output: "12MiB" +// format="% d" output: "12 MiB" +// +func Current(unit int, format string, wcc ...WC) Decorator { + producer := func(unit int, format string) DecorFunc { + if format == "" { + format = "%d" + } else if strings.Count(format, "%") != 1 { + panic("expected format with exactly 1 verb") + } + + switch unit { + case UnitKiB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1024(s.Current)) + } + case UnitKB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1000(s.Current)) + } + default: + return func(s Statistics) string { + return fmt.Sprintf(format, s.Current) + } + } + } + return Any(producer(unit, format), wcc...) +} + +// InvertedCurrentNoUnit is a wrapper around InvertedCurrent with no unit param. +func InvertedCurrentNoUnit(format string, wcc ...WC) Decorator { + return InvertedCurrent(0, format, wcc...) +} + +// InvertedCurrentKibiByte is a wrapper around InvertedCurrent with predefined unit +// UnitKiB (bytes/1024). +func InvertedCurrentKibiByte(format string, wcc ...WC) Decorator { + return InvertedCurrent(UnitKiB, format, wcc...) +} + +// InvertedCurrentKiloByte is a wrapper around InvertedCurrent with predefined unit +// UnitKB (bytes/1000). +func InvertedCurrentKiloByte(format string, wcc ...WC) Decorator { + return InvertedCurrent(UnitKB, format, wcc...) +} + +// InvertedCurrent decorator with dynamic unit measure adjustment. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `format` printf compatible verb for InvertedCurrent +// +// `wcc` optional WC config +// +// format example if unit=UnitKiB: +// +// format="%.1f" output: "12.0MiB" +// format="% .1f" output: "12.0 MiB" +// format="%d" output: "12MiB" +// format="% d" output: "12 MiB" +// +func InvertedCurrent(unit int, format string, wcc ...WC) Decorator { + producer := func(unit int, format string) DecorFunc { + if format == "" { + format = "%d" + } else if strings.Count(format, "%") != 1 { + panic("expected format with exactly 1 verb") + } + + switch unit { + case UnitKiB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1024(s.Total-s.Current)) + } + case UnitKB: + return func(s Statistics) string { + return fmt.Sprintf(format, SizeB1000(s.Total-s.Current)) + } + default: + return func(s Statistics) string { + return fmt.Sprintf(format, s.Total-s.Current) + } + } + } + return Any(producer(unit, format), wcc...) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go b/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go new file mode 100644 index 000000000..e81fae367 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/decorator.go @@ -0,0 +1,191 @@ +package decor + +import ( + "fmt" + "time" + + "github.com/acarl005/stripansi" + "github.com/mattn/go-runewidth" +) + +const ( + // DidentRight bit specifies identation direction. + // |foo |b | With DidentRight + // | foo| b| Without DidentRight + DidentRight = 1 << iota + + // DextraSpace bit adds extra space, makes sense with DSyncWidth only. + // When DidentRight bit set, the space will be added to the right, + // otherwise to the left. + DextraSpace + + // DSyncWidth bit enables same column width synchronization. + // Effective with multiple bars only. + DSyncWidth + + // DSyncWidthR is shortcut for DSyncWidth|DidentRight + DSyncWidthR = DSyncWidth | DidentRight + + // DSyncSpace is shortcut for DSyncWidth|DextraSpace + DSyncSpace = DSyncWidth | DextraSpace + + // DSyncSpaceR is shortcut for DSyncWidth|DextraSpace|DidentRight + DSyncSpaceR = DSyncWidth | DextraSpace | DidentRight +) + +// TimeStyle enum. +type TimeStyle int + +// TimeStyle kinds. +const ( + ET_STYLE_GO TimeStyle = iota + ET_STYLE_HHMMSS + ET_STYLE_HHMM + ET_STYLE_MMSS +) + +// Statistics consists of progress related statistics, that Decorator +// may need. +type Statistics struct { + ID int + AvailableWidth int + Total int64 + Current int64 + Refill int64 + Completed bool +} + +// Decorator interface. +// Most of the time there is no need to implement this interface +// manually, as decor package already provides a wide range of decorators +// which implement this interface. If however built-in decorators don't +// meet your needs, you're free to implement your own one by implementing +// this particular interface. The easy way to go is to convert a +// `DecorFunc` into a `Decorator` interface by using provided +// `func Any(DecorFunc, ...WC) Decorator`. +type Decorator interface { + Configurator + Synchronizer + Decor(Statistics) string +} + +// DecorFunc func type. +// To be used with `func Any`(DecorFunc, ...WC) Decorator`. +type DecorFunc func(Statistics) string + +// Synchronizer interface. +// All decorators implement this interface implicitly. Its Sync +// method exposes width sync channel, if DSyncWidth bit is set. +type Synchronizer interface { + Sync() (chan int, bool) +} + +// Configurator interface. +type Configurator interface { + GetConf() WC + SetConf(WC) +} + +// Wrapper interface. +// If you're implementing custom Decorator by wrapping a built-in one, +// it is necessary to implement this interface to retain functionality +// of built-in Decorator. +type Wrapper interface { + Base() Decorator +} + +// EwmaDecorator interface. +// EWMA based decorators should implement this one. +type EwmaDecorator interface { + EwmaUpdate(int64, time.Duration) +} + +// AverageDecorator interface. +// Average decorators should implement this interface to provide start +// time adjustment facility, for resume-able tasks. +type AverageDecorator interface { + AverageAdjust(time.Time) +} + +// ShutdownListener interface. +// If decorator needs to be notified once upon bar shutdown event, so +// this is the right interface to implement. +type ShutdownListener interface { + Shutdown() +} + +// Global convenience instances of WC with sync width bit set. +// To be used with multiple bars only, i.e. not effective for single bar usage. +var ( + WCSyncWidth = WC{C: DSyncWidth} + WCSyncWidthR = WC{C: DSyncWidthR} + WCSyncSpace = WC{C: DSyncSpace} + WCSyncSpaceR = WC{C: DSyncSpaceR} +) + +// WC is a struct with two public fields W and C, both of int type. +// W represents width and C represents bit set of width related config. +// A decorator should embed WC, to enable width synchronization. +type WC struct { + W int + C int + fill func(s string, w int) string + wsync chan int +} + +// FormatMsg formats final message according to WC.W and WC.C. +// Should be called by any Decorator implementation. +func (wc *WC) FormatMsg(msg string) string { + pureWidth := runewidth.StringWidth(msg) + stripWidth := runewidth.StringWidth(stripansi.Strip(msg)) + maxCell := wc.W + if (wc.C & DSyncWidth) != 0 { + cellCount := stripWidth + if (wc.C & DextraSpace) != 0 { + cellCount++ + } + wc.wsync <- cellCount + maxCell = <-wc.wsync + } + return wc.fill(msg, maxCell+(pureWidth-stripWidth)) +} + +// Init initializes width related config. +func (wc *WC) Init() WC { + wc.fill = runewidth.FillLeft + if (wc.C & DidentRight) != 0 { + wc.fill = runewidth.FillRight + } + if (wc.C & DSyncWidth) != 0 { + // it's deliberate choice to override wsync on each Init() call, + // this way globals like WCSyncSpace can be reused + wc.wsync = make(chan int) + } + return *wc +} + +// Sync is implementation of Synchronizer interface. +func (wc *WC) Sync() (chan int, bool) { + if (wc.C&DSyncWidth) != 0 && wc.wsync == nil { + panic(fmt.Sprintf("%T is not initialized", wc)) + } + return wc.wsync, (wc.C & DSyncWidth) != 0 +} + +// GetConf is implementation of Configurator interface. +func (wc *WC) GetConf() WC { + return *wc +} + +// SetConf is implementation of Configurator interface. +func (wc *WC) SetConf(conf WC) { + *wc = conf.Init() +} + +func initWC(wcc ...WC) WC { + var wc WC + for _, nwc := range wcc { + wc = nwc + } + return wc.Init() +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/doc.go b/vendor/github.com/vbauerster/mpb/v6/decor/doc.go new file mode 100644 index 000000000..bfbb82e11 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/doc.go @@ -0,0 +1,20 @@ +// Package decor provides common decorators for "github.com/vbauerster/mpb/v6" module. +/* + Some decorators returned by this package might have a closure state. It is ok to use + decorators concurrently, unless you share the same decorator among multiple + *mpb.Bar instances. To avoid data races, create new decorator per *mpb.Bar instance. + + Don't: + + p := mpb.New() + name := decor.Name("bar") + p.AddBar(100, mpb.AppendDecorators(name)) + p.AddBar(100, mpb.AppendDecorators(name)) + + Do: + + p := mpb.New() + p.AddBar(100, mpb.AppendDecorators(decor.Name("bar1"))) + p.AddBar(100, mpb.AppendDecorators(decor.Name("bar2"))) +*/ +package decor diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go b/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go new file mode 100644 index 000000000..e389f1581 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/elapsed.go @@ -0,0 +1,35 @@ +package decor + +import ( + "time" +) + +// Elapsed decorator. It's wrapper of NewElapsed. +// +// `style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS] +// +// `wcc` optional WC config +// +func Elapsed(style TimeStyle, wcc ...WC) Decorator { + return NewElapsed(style, time.Now(), wcc...) +} + +// NewElapsed returns elapsed time decorator. +// +// `style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS] +// +// `startTime` start time +// +// `wcc` optional WC config +// +func NewElapsed(style TimeStyle, startTime time.Time, wcc ...WC) Decorator { + var msg string + producer := chooseTimeProducer(style) + fn := func(s Statistics) string { + if !s.Completed { + msg = producer(time.Since(startTime)) + } + return msg + } + return Any(fn, wcc...) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/eta.go b/vendor/github.com/vbauerster/mpb/v6/decor/eta.go new file mode 100644 index 000000000..d03caa735 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/eta.go @@ -0,0 +1,203 @@ +package decor + +import ( + "fmt" + "math" + "time" + + "github.com/VividCortex/ewma" +) + +// TimeNormalizer interface. Implementors could be passed into +// MovingAverageETA, in order to affect i.e. normalize its output. +type TimeNormalizer interface { + Normalize(time.Duration) time.Duration +} + +// TimeNormalizerFunc is function type adapter to convert function +// into TimeNormalizer. +type TimeNormalizerFunc func(time.Duration) time.Duration + +func (f TimeNormalizerFunc) Normalize(src time.Duration) time.Duration { + return f(src) +} + +// EwmaETA exponential-weighted-moving-average based ETA decorator. +// For this decorator to work correctly you have to measure each +// iteration's duration and pass it to the +// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment. +func EwmaETA(style TimeStyle, age float64, wcc ...WC) Decorator { + var average ewma.MovingAverage + if age == 0 { + average = ewma.NewMovingAverage() + } else { + average = ewma.NewMovingAverage(age) + } + return MovingAverageETA(style, NewThreadSafeMovingAverage(average), nil, wcc...) +} + +// MovingAverageETA decorator relies on MovingAverage implementation to calculate its average. +// +// `style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS] +// +// `average` implementation of MovingAverage interface +// +// `normalizer` available implementations are [FixedIntervalTimeNormalizer|MaxTolerateTimeNormalizer] +// +// `wcc` optional WC config +// +func MovingAverageETA(style TimeStyle, average ewma.MovingAverage, normalizer TimeNormalizer, wcc ...WC) Decorator { + d := &movingAverageETA{ + WC: initWC(wcc...), + average: average, + normalizer: normalizer, + producer: chooseTimeProducer(style), + } + return d +} + +type movingAverageETA struct { + WC + average ewma.MovingAverage + normalizer TimeNormalizer + producer func(time.Duration) string +} + +func (d *movingAverageETA) Decor(s Statistics) string { + v := math.Round(d.average.Value()) + remaining := time.Duration((s.Total - s.Current) * int64(v)) + if d.normalizer != nil { + remaining = d.normalizer.Normalize(remaining) + } + return d.FormatMsg(d.producer(remaining)) +} + +func (d *movingAverageETA) EwmaUpdate(n int64, dur time.Duration) { + durPerItem := float64(dur) / float64(n) + if math.IsInf(durPerItem, 0) || math.IsNaN(durPerItem) { + return + } + d.average.Add(durPerItem) +} + +// AverageETA decorator. It's wrapper of NewAverageETA. +// +// `style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS] +// +// `wcc` optional WC config +// +func AverageETA(style TimeStyle, wcc ...WC) Decorator { + return NewAverageETA(style, time.Now(), nil, wcc...) +} + +// NewAverageETA decorator with user provided start time. +// +// `style` one of [ET_STYLE_GO|ET_STYLE_HHMMSS|ET_STYLE_HHMM|ET_STYLE_MMSS] +// +// `startTime` start time +// +// `normalizer` available implementations are [FixedIntervalTimeNormalizer|MaxTolerateTimeNormalizer] +// +// `wcc` optional WC config +// +func NewAverageETA(style TimeStyle, startTime time.Time, normalizer TimeNormalizer, wcc ...WC) Decorator { + d := &averageETA{ + WC: initWC(wcc...), + startTime: startTime, + normalizer: normalizer, + producer: chooseTimeProducer(style), + } + return d +} + +type averageETA struct { + WC + startTime time.Time + normalizer TimeNormalizer + producer func(time.Duration) string +} + +func (d *averageETA) Decor(s Statistics) string { + var remaining time.Duration + if s.Current != 0 { + durPerItem := float64(time.Since(d.startTime)) / float64(s.Current) + durPerItem = math.Round(durPerItem) + remaining = time.Duration((s.Total - s.Current) * int64(durPerItem)) + if d.normalizer != nil { + remaining = d.normalizer.Normalize(remaining) + } + } + return d.FormatMsg(d.producer(remaining)) +} + +func (d *averageETA) AverageAdjust(startTime time.Time) { + d.startTime = startTime +} + +// MaxTolerateTimeNormalizer returns implementation of TimeNormalizer. +func MaxTolerateTimeNormalizer(maxTolerate time.Duration) TimeNormalizer { + var normalized time.Duration + var lastCall time.Time + return TimeNormalizerFunc(func(remaining time.Duration) time.Duration { + if diff := normalized - remaining; diff <= 0 || diff > maxTolerate || remaining < time.Minute { + normalized = remaining + lastCall = time.Now() + return remaining + } + normalized -= time.Since(lastCall) + lastCall = time.Now() + return normalized + }) +} + +// FixedIntervalTimeNormalizer returns implementation of TimeNormalizer. +func FixedIntervalTimeNormalizer(updInterval int) TimeNormalizer { + var normalized time.Duration + var lastCall time.Time + var count int + return TimeNormalizerFunc(func(remaining time.Duration) time.Duration { + if count == 0 || remaining < time.Minute { + count = updInterval + normalized = remaining + lastCall = time.Now() + return remaining + } + count-- + normalized -= time.Since(lastCall) + lastCall = time.Now() + return normalized + }) +} + +func chooseTimeProducer(style TimeStyle) func(time.Duration) string { + switch style { + case ET_STYLE_HHMMSS: + return func(remaining time.Duration) string { + hours := int64(remaining/time.Hour) % 60 + minutes := int64(remaining/time.Minute) % 60 + seconds := int64(remaining/time.Second) % 60 + return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds) + } + case ET_STYLE_HHMM: + return func(remaining time.Duration) string { + hours := int64(remaining/time.Hour) % 60 + minutes := int64(remaining/time.Minute) % 60 + return fmt.Sprintf("%02d:%02d", hours, minutes) + } + case ET_STYLE_MMSS: + return func(remaining time.Duration) string { + hours := int64(remaining/time.Hour) % 60 + minutes := int64(remaining/time.Minute) % 60 + seconds := int64(remaining/time.Second) % 60 + if hours > 0 { + return fmt.Sprintf("%02d:%02d:%02d", hours, minutes, seconds) + } + return fmt.Sprintf("%02d:%02d", minutes, seconds) + } + default: + return func(remaining time.Duration) string { + // strip off nanoseconds + return ((remaining / time.Second) * time.Second).String() + } + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/merge.go b/vendor/github.com/vbauerster/mpb/v6/decor/merge.go new file mode 100644 index 000000000..e41406a64 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/merge.go @@ -0,0 +1,107 @@ +package decor + +import ( + "strings" + + "github.com/acarl005/stripansi" + "github.com/mattn/go-runewidth" +) + +// Merge wraps its decorator argument with intention to sync width +// with several decorators of another bar. Visual example: +// +// +----+--------+---------+--------+ +// | B1 | MERGE(D, P1, Pn) | +// +----+--------+---------+--------+ +// | B2 | D0 | D1 | Dn | +// +----+--------+---------+--------+ +// +func Merge(decorator Decorator, placeholders ...WC) Decorator { + if _, ok := decorator.Sync(); !ok || len(placeholders) == 0 { + return decorator + } + md := &mergeDecorator{ + Decorator: decorator, + wc: decorator.GetConf(), + placeHolders: make([]*placeHolderDecorator, len(placeholders)), + } + decorator.SetConf(WC{}) + for i, wc := range placeholders { + if (wc.C & DSyncWidth) == 0 { + return decorator + } + md.placeHolders[i] = &placeHolderDecorator{wc.Init()} + } + return md +} + +type mergeDecorator struct { + Decorator + wc WC + placeHolders []*placeHolderDecorator +} + +func (d *mergeDecorator) GetConf() WC { + return d.wc +} + +func (d *mergeDecorator) SetConf(conf WC) { + d.wc = conf.Init() +} + +func (d *mergeDecorator) MergeUnwrap() []Decorator { + decorators := make([]Decorator, len(d.placeHolders)) + for i, ph := range d.placeHolders { + decorators[i] = ph + } + return decorators +} + +func (d *mergeDecorator) Sync() (chan int, bool) { + return d.wc.Sync() +} + +func (d *mergeDecorator) Base() Decorator { + return d.Decorator +} + +func (d *mergeDecorator) Decor(s Statistics) string { + msg := d.Decorator.Decor(s) + pureWidth := runewidth.StringWidth(msg) + stripWidth := runewidth.StringWidth(stripansi.Strip(msg)) + cellCount := stripWidth + if (d.wc.C & DextraSpace) != 0 { + cellCount++ + } + + total := runewidth.StringWidth(d.placeHolders[0].FormatMsg("")) + pw := (cellCount - total) / len(d.placeHolders) + rem := (cellCount - total) % len(d.placeHolders) + + var diff int + for i := 1; i < len(d.placeHolders); i++ { + ph := d.placeHolders[i] + width := pw - diff + if (ph.WC.C & DextraSpace) != 0 { + width-- + if width < 0 { + width = 0 + } + } + max := runewidth.StringWidth(ph.FormatMsg(strings.Repeat(" ", width))) + total += max + diff = max - pw + } + + d.wc.wsync <- pw + rem + max := <-d.wc.wsync + return d.wc.fill(msg, max+total+(pureWidth-stripWidth)) +} + +type placeHolderDecorator struct { + WC +} + +func (d *placeHolderDecorator) Decor(Statistics) string { + return "" +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go b/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go new file mode 100644 index 000000000..50ac9c393 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/moving_average.go @@ -0,0 +1,68 @@ +package decor + +import ( + "sort" + "sync" + + "github.com/VividCortex/ewma" +) + +type threadSafeMovingAverage struct { + ewma.MovingAverage + mu sync.Mutex +} + +func (s *threadSafeMovingAverage) Add(value float64) { + s.mu.Lock() + s.MovingAverage.Add(value) + s.mu.Unlock() +} + +func (s *threadSafeMovingAverage) Value() float64 { + s.mu.Lock() + defer s.mu.Unlock() + return s.MovingAverage.Value() +} + +func (s *threadSafeMovingAverage) Set(value float64) { + s.mu.Lock() + s.MovingAverage.Set(value) + s.mu.Unlock() +} + +// NewThreadSafeMovingAverage converts provided ewma.MovingAverage +// into thread safe ewma.MovingAverage. +func NewThreadSafeMovingAverage(average ewma.MovingAverage) ewma.MovingAverage { + if tsma, ok := average.(*threadSafeMovingAverage); ok { + return tsma + } + return &threadSafeMovingAverage{MovingAverage: average} +} + +type medianWindow [3]float64 + +func (s *medianWindow) Len() int { return len(s) } +func (s *medianWindow) Swap(i, j int) { s[i], s[j] = s[j], s[i] } +func (s *medianWindow) Less(i, j int) bool { return s[i] < s[j] } + +func (s *medianWindow) Add(value float64) { + s[0], s[1] = s[1], s[2] + s[2] = value +} + +func (s *medianWindow) Value() float64 { + tmp := *s + sort.Sort(&tmp) + return tmp[1] +} + +func (s *medianWindow) Set(value float64) { + for i := 0; i < len(s); i++ { + s[i] = value + } +} + +// NewMedian is fixed last 3 samples median MovingAverage. +func NewMedian() ewma.MovingAverage { + return NewThreadSafeMovingAverage(new(medianWindow)) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/name.go b/vendor/github.com/vbauerster/mpb/v6/decor/name.go new file mode 100644 index 000000000..3af311254 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/name.go @@ -0,0 +1,12 @@ +package decor + +// Name decorator displays text that is set once and can't be changed +// during decorator's lifetime. +// +// `str` string to display +// +// `wcc` optional WC config +// +func Name(str string, wcc ...WC) Decorator { + return Any(func(Statistics) string { return str }, wcc...) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go b/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go new file mode 100644 index 000000000..f46b19aba --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/on_complete.go @@ -0,0 +1,37 @@ +package decor + +// OnComplete returns decorator, which wraps provided decorator, with +// sole purpose to display provided message on complete event. +// +// `decorator` Decorator to wrap +// +// `message` message to display on complete event +// +func OnComplete(decorator Decorator, message string) Decorator { + d := &onCompleteWrapper{ + Decorator: decorator, + msg: message, + } + if md, ok := decorator.(*mergeDecorator); ok { + d.Decorator, md.Decorator = md.Decorator, d + return md + } + return d +} + +type onCompleteWrapper struct { + Decorator + msg string +} + +func (d *onCompleteWrapper) Decor(s Statistics) string { + if s.Completed { + wc := d.GetConf() + return wc.FormatMsg(d.msg) + } + return d.Decorator.Decor(s) +} + +func (d *onCompleteWrapper) Base() Decorator { + return d.Decorator +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go b/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go new file mode 100644 index 000000000..f4922bb52 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/percentage.go @@ -0,0 +1,58 @@ +package decor + +import ( + "fmt" + "io" + "strconv" + + "github.com/vbauerster/mpb/v6/internal" +) + +type percentageType float64 + +func (s percentageType) Format(st fmt.State, verb rune) { + var prec int + switch verb { + case 'd': + case 's': + prec = -1 + default: + if p, ok := st.Precision(); ok { + prec = p + } else { + prec = 6 + } + } + + io.WriteString(st, strconv.FormatFloat(float64(s), 'f', prec, 64)) + + if st.Flag(' ') { + io.WriteString(st, " ") + } + io.WriteString(st, "%") +} + +// Percentage returns percentage decorator. It's a wrapper of NewPercentage. +func Percentage(wcc ...WC) Decorator { + return NewPercentage("% d", wcc...) +} + +// NewPercentage percentage decorator with custom format string. +// +// format examples: +// +// format="%.1f" output: "1.0%" +// format="% .1f" output: "1.0 %" +// format="%d" output: "1%" +// format="% d" output: "1 %" +// +func NewPercentage(format string, wcc ...WC) Decorator { + if format == "" { + format = "% d" + } + f := func(s Statistics) string { + p := internal.Percentage(s.Total, s.Current, 100) + return fmt.Sprintf(format, percentageType(p)) + } + return Any(f, wcc...) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go b/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go new file mode 100644 index 000000000..e4b974058 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/size_type.go @@ -0,0 +1,109 @@ +package decor + +import ( + "fmt" + "io" + "math" + "strconv" +) + +//go:generate stringer -type=SizeB1024 -trimprefix=_i +//go:generate stringer -type=SizeB1000 -trimprefix=_ + +const ( + _ib SizeB1024 = iota + 1 + _iKiB SizeB1024 = 1 << (iota * 10) + _iMiB + _iGiB + _iTiB +) + +// SizeB1024 named type, which implements fmt.Formatter interface. It +// adjusts its value according to byte size multiple by 1024 and appends +// appropriate size marker (KiB, MiB, GiB, TiB). +type SizeB1024 int64 + +func (self SizeB1024) Format(st fmt.State, verb rune) { + var prec int + switch verb { + case 'd': + case 's': + prec = -1 + default: + if p, ok := st.Precision(); ok { + prec = p + } else { + prec = 6 + } + } + + var unit SizeB1024 + switch { + case self < _iKiB: + unit = _ib + case self < _iMiB: + unit = _iKiB + case self < _iGiB: + unit = _iMiB + case self < _iTiB: + unit = _iGiB + case self <= math.MaxInt64: + unit = _iTiB + } + + io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64)) + + if st.Flag(' ') { + io.WriteString(st, " ") + } + io.WriteString(st, unit.String()) +} + +const ( + _b SizeB1000 = 1 + _KB SizeB1000 = _b * 1000 + _MB SizeB1000 = _KB * 1000 + _GB SizeB1000 = _MB * 1000 + _TB SizeB1000 = _GB * 1000 +) + +// SizeB1000 named type, which implements fmt.Formatter interface. It +// adjusts its value according to byte size multiple by 1000 and appends +// appropriate size marker (KB, MB, GB, TB). +type SizeB1000 int64 + +func (self SizeB1000) Format(st fmt.State, verb rune) { + var prec int + switch verb { + case 'd': + case 's': + prec = -1 + default: + if p, ok := st.Precision(); ok { + prec = p + } else { + prec = 6 + } + } + + var unit SizeB1000 + switch { + case self < _KB: + unit = _b + case self < _MB: + unit = _KB + case self < _GB: + unit = _MB + case self < _TB: + unit = _GB + case self <= math.MaxInt64: + unit = _TB + } + + io.WriteString(st, strconv.FormatFloat(float64(self)/float64(unit), 'f', prec, 64)) + + if st.Flag(' ') { + io.WriteString(st, " ") + } + io.WriteString(st, unit.String()) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go new file mode 100644 index 000000000..3f32ef715 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1000_string.go @@ -0,0 +1,41 @@ +// Code generated by "stringer -type=SizeB1000 -trimprefix=_"; DO NOT EDIT. + +package decor + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[_b-1] + _ = x[_KB-1000] + _ = x[_MB-1000000] + _ = x[_GB-1000000000] + _ = x[_TB-1000000000000] +} + +const ( + _SizeB1000_name_0 = "b" + _SizeB1000_name_1 = "KB" + _SizeB1000_name_2 = "MB" + _SizeB1000_name_3 = "GB" + _SizeB1000_name_4 = "TB" +) + +func (i SizeB1000) String() string { + switch { + case i == 1: + return _SizeB1000_name_0 + case i == 1000: + return _SizeB1000_name_1 + case i == 1000000: + return _SizeB1000_name_2 + case i == 1000000000: + return _SizeB1000_name_3 + case i == 1000000000000: + return _SizeB1000_name_4 + default: + return "SizeB1000(" + strconv.FormatInt(int64(i), 10) + ")" + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go new file mode 100644 index 000000000..9fca66cc7 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/sizeb1024_string.go @@ -0,0 +1,41 @@ +// Code generated by "stringer -type=SizeB1024 -trimprefix=_i"; DO NOT EDIT. + +package decor + +import "strconv" + +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[_ib-1] + _ = x[_iKiB-1024] + _ = x[_iMiB-1048576] + _ = x[_iGiB-1073741824] + _ = x[_iTiB-1099511627776] +} + +const ( + _SizeB1024_name_0 = "b" + _SizeB1024_name_1 = "KiB" + _SizeB1024_name_2 = "MiB" + _SizeB1024_name_3 = "GiB" + _SizeB1024_name_4 = "TiB" +) + +func (i SizeB1024) String() string { + switch { + case i == 1: + return _SizeB1024_name_0 + case i == 1024: + return _SizeB1024_name_1 + case i == 1048576: + return _SizeB1024_name_2 + case i == 1073741824: + return _SizeB1024_name_3 + case i == 1099511627776: + return _SizeB1024_name_4 + default: + return "SizeB1024(" + strconv.FormatInt(int64(i), 10) + ")" + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/speed.go b/vendor/github.com/vbauerster/mpb/v6/decor/speed.go new file mode 100644 index 000000000..634edabfd --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/speed.go @@ -0,0 +1,171 @@ +package decor + +import ( + "fmt" + "io" + "math" + "time" + + "github.com/VividCortex/ewma" +) + +// FmtAsSpeed adds "/s" to the end of the input formatter. To be +// used with SizeB1000 or SizeB1024 types, for example: +// +// fmt.Printf("%.1f", FmtAsSpeed(SizeB1024(2048))) +// +func FmtAsSpeed(input fmt.Formatter) fmt.Formatter { + return &speedFormatter{input} +} + +type speedFormatter struct { + fmt.Formatter +} + +func (self *speedFormatter) Format(st fmt.State, verb rune) { + self.Formatter.Format(st, verb) + io.WriteString(st, "/s") +} + +// EwmaSpeed exponential-weighted-moving-average based speed decorator. +// For this decorator to work correctly you have to measure each +// iteration's duration and pass it to the +// *Bar.DecoratorEwmaUpdate(time.Duration) method after each increment. +func EwmaSpeed(unit int, format string, age float64, wcc ...WC) Decorator { + var average ewma.MovingAverage + if age == 0 { + average = ewma.NewMovingAverage() + } else { + average = ewma.NewMovingAverage(age) + } + return MovingAverageSpeed(unit, format, NewThreadSafeMovingAverage(average), wcc...) +} + +// MovingAverageSpeed decorator relies on MovingAverage implementation +// to calculate its average. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `format` printf compatible verb for value, like "%f" or "%d" +// +// `average` MovingAverage implementation +// +// `wcc` optional WC config +// +// format examples: +// +// unit=UnitKiB, format="%.1f" output: "1.0MiB/s" +// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s" +// unit=UnitKB, format="%.1f" output: "1.0MB/s" +// unit=UnitKB, format="% .1f" output: "1.0 MB/s" +// +func MovingAverageSpeed(unit int, format string, average ewma.MovingAverage, wcc ...WC) Decorator { + if format == "" { + format = "%.0f" + } + d := &movingAverageSpeed{ + WC: initWC(wcc...), + average: average, + producer: chooseSpeedProducer(unit, format), + } + return d +} + +type movingAverageSpeed struct { + WC + producer func(float64) string + average ewma.MovingAverage + msg string +} + +func (d *movingAverageSpeed) Decor(s Statistics) string { + if !s.Completed { + var speed float64 + if v := d.average.Value(); v > 0 { + speed = 1 / v + } + d.msg = d.producer(speed * 1e9) + } + return d.FormatMsg(d.msg) +} + +func (d *movingAverageSpeed) EwmaUpdate(n int64, dur time.Duration) { + durPerByte := float64(dur) / float64(n) + if math.IsInf(durPerByte, 0) || math.IsNaN(durPerByte) { + return + } + d.average.Add(durPerByte) +} + +// AverageSpeed decorator with dynamic unit measure adjustment. It's +// a wrapper of NewAverageSpeed. +func AverageSpeed(unit int, format string, wcc ...WC) Decorator { + return NewAverageSpeed(unit, format, time.Now(), wcc...) +} + +// NewAverageSpeed decorator with dynamic unit measure adjustment and +// user provided start time. +// +// `unit` one of [0|UnitKiB|UnitKB] zero for no unit +// +// `format` printf compatible verb for value, like "%f" or "%d" +// +// `startTime` start time +// +// `wcc` optional WC config +// +// format examples: +// +// unit=UnitKiB, format="%.1f" output: "1.0MiB/s" +// unit=UnitKiB, format="% .1f" output: "1.0 MiB/s" +// unit=UnitKB, format="%.1f" output: "1.0MB/s" +// unit=UnitKB, format="% .1f" output: "1.0 MB/s" +// +func NewAverageSpeed(unit int, format string, startTime time.Time, wcc ...WC) Decorator { + if format == "" { + format = "%.0f" + } + d := &averageSpeed{ + WC: initWC(wcc...), + startTime: startTime, + producer: chooseSpeedProducer(unit, format), + } + return d +} + +type averageSpeed struct { + WC + startTime time.Time + producer func(float64) string + msg string +} + +func (d *averageSpeed) Decor(s Statistics) string { + if !s.Completed { + speed := float64(s.Current) / float64(time.Since(d.startTime)) + d.msg = d.producer(speed * 1e9) + } + + return d.FormatMsg(d.msg) +} + +func (d *averageSpeed) AverageAdjust(startTime time.Time) { + d.startTime = startTime +} + +func chooseSpeedProducer(unit int, format string) func(float64) string { + switch unit { + case UnitKiB: + return func(speed float64) string { + return fmt.Sprintf(format, FmtAsSpeed(SizeB1024(math.Round(speed)))) + } + case UnitKB: + return func(speed float64) string { + return fmt.Sprintf(format, FmtAsSpeed(SizeB1000(math.Round(speed)))) + } + default: + return func(speed float64) string { + return fmt.Sprintf(format, speed) + } + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go b/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go new file mode 100644 index 000000000..6871639db --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/decor/spinner.go @@ -0,0 +1,21 @@ +package decor + +var defaultSpinnerStyle = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"} + +// Spinner returns spinner decorator. +// +// `frames` spinner frames, if nil or len==0, default is used +// +// `wcc` optional WC config +func Spinner(frames []string, wcc ...WC) Decorator { + if len(frames) == 0 { + frames = defaultSpinnerStyle + } + var count uint + f := func(s Statistics) string { + frame := frames[count%uint(len(frames))] + count++ + return frame + } + return Any(f, wcc...) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/doc.go b/vendor/github.com/vbauerster/mpb/v6/doc.go new file mode 100644 index 000000000..5ada71774 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/doc.go @@ -0,0 +1,2 @@ +// Package mpb is a library for rendering progress bars in terminal applications. +package mpb diff --git a/vendor/github.com/vbauerster/mpb/v6/go.mod b/vendor/github.com/vbauerster/mpb/v6/go.mod new file mode 100644 index 000000000..3a3d337d2 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/go.mod @@ -0,0 +1,11 @@ +module github.com/vbauerster/mpb/v6 + +require ( + github.com/VividCortex/ewma v1.1.1 + github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d + github.com/mattn/go-runewidth v0.0.10 + github.com/rivo/uniseg v0.2.0 + golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 +) + +go 1.14 diff --git a/vendor/github.com/vbauerster/mpb/v6/go.sum b/vendor/github.com/vbauerster/mpb/v6/go.sum new file mode 100644 index 000000000..1c20f8921 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/go.sum @@ -0,0 +1,11 @@ +github.com/VividCortex/ewma v1.1.1 h1:MnEK4VOv6n0RSY4vtRe3h11qjxL3+t0B8yOL8iMXdcM= +github.com/VividCortex/ewma v1.1.1/go.mod h1:2Tkkvm3sRDVXaiyucHiACn4cqf7DpdyLvmxzcbUokwA= +github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8= +github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo= +github.com/mattn/go-runewidth v0.0.10 h1:CoZ3S2P7pvtP45xOtBw+/mDL2z0RKI576gSkzRRpdGg= +github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk= +github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78 h1:nVuTkr9L6Bq62qpUqKo/RnZCFfzDBL0bYo6w9OJUqZY= +golang.org/x/sys v0.0.0-20210113181707-4bcb84eeeb78/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go b/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go new file mode 100644 index 000000000..a8ef8be12 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/internal/percentage.go @@ -0,0 +1,19 @@ +package internal + +import "math" + +// Percentage is a helper function, to calculate percentage. +func Percentage(total, current int64, width int) float64 { + if total <= 0 { + return 0 + } + if current >= total { + return float64(width) + } + return float64(int64(width)*current) / float64(total) +} + +// PercentageRound same as Percentage but with math.Round. +func PercentageRound(total, current int64, width int) float64 { + return math.Round(Percentage(total, current, width)) +} diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go b/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go new file mode 100644 index 000000000..1e4dd24d9 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/internal/predicate.go @@ -0,0 +1,6 @@ +package internal + +// Predicate helper for internal use. +func Predicate(pick bool) func() bool { + return func() bool { return pick } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/internal/width.go b/vendor/github.com/vbauerster/mpb/v6/internal/width.go new file mode 100644 index 000000000..216320f24 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/internal/width.go @@ -0,0 +1,10 @@ +package internal + +// CheckRequestedWidth checks that requested width doesn't overflow +// available width +func CheckRequestedWidth(requested, available int) int { + if requested <= 0 || requested >= available { + return available + } + return requested +} diff --git a/vendor/github.com/vbauerster/mpb/v6/priority_queue.go b/vendor/github.com/vbauerster/mpb/v6/priority_queue.go new file mode 100644 index 000000000..29d9bd5a8 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/priority_queue.go @@ -0,0 +1,32 @@ +package mpb + +// A priorityQueue implements heap.Interface +type priorityQueue []*Bar + +func (pq priorityQueue) Len() int { return len(pq) } + +func (pq priorityQueue) Less(i, j int) bool { + return pq[i].priority < pq[j].priority +} + +func (pq priorityQueue) Swap(i, j int) { + pq[i], pq[j] = pq[j], pq[i] + pq[i].index = i + pq[j].index = j +} + +func (pq *priorityQueue) Push(x interface{}) { + s := *pq + bar := x.(*Bar) + bar.index = len(s) + s = append(s, bar) + *pq = s +} + +func (pq *priorityQueue) Pop() interface{} { + s := *pq + *pq = s[0 : len(s)-1] + bar := s[len(s)-1] + bar.index = -1 // for safety + return bar +} diff --git a/vendor/github.com/vbauerster/mpb/v6/progress.go b/vendor/github.com/vbauerster/mpb/v6/progress.go new file mode 100644 index 000000000..5a3f96243 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/progress.go @@ -0,0 +1,412 @@ +package mpb + +import ( + "bytes" + "container/heap" + "context" + "fmt" + "io" + "io/ioutil" + "log" + "math" + "os" + "sync" + "time" + + "github.com/vbauerster/mpb/v6/cwriter" + "github.com/vbauerster/mpb/v6/decor" +) + +const ( + // default RefreshRate + prr = 120 * time.Millisecond +) + +// Progress represents a container that renders one or more progress +// bars. +type Progress struct { + ctx context.Context + uwg *sync.WaitGroup + cwg *sync.WaitGroup + bwg *sync.WaitGroup + operateState chan func(*pState) + done chan struct{} + refreshCh chan time.Time + once sync.Once + dlogger *log.Logger +} + +// pState holds bars in its priorityQueue. It gets passed to +// *Progress.serve(...) monitor goroutine. +type pState struct { + bHeap priorityQueue + heapUpdated bool + pMatrix map[int][]chan int + aMatrix map[int][]chan int + barShutdownQueue []*Bar + + // following are provided/overrided by user + idCount int + reqWidth int + popCompleted bool + outputDiscarded bool + rr time.Duration + uwg *sync.WaitGroup + externalRefresh <-chan interface{} + renderDelay <-chan struct{} + shutdownNotifier chan struct{} + parkedBars map[*Bar]*Bar + output io.Writer + debugOut io.Writer +} + +// New creates new Progress container instance. It's not possible to +// reuse instance after *Progress.Wait() method has been called. +func New(options ...ContainerOption) *Progress { + return NewWithContext(context.Background(), options...) +} + +// NewWithContext creates new Progress container instance with provided +// context. It's not possible to reuse instance after *Progress.Wait() +// method has been called. +func NewWithContext(ctx context.Context, options ...ContainerOption) *Progress { + s := &pState{ + bHeap: priorityQueue{}, + rr: prr, + parkedBars: make(map[*Bar]*Bar), + output: os.Stdout, + debugOut: ioutil.Discard, + } + + for _, opt := range options { + if opt != nil { + opt(s) + } + } + + p := &Progress{ + ctx: ctx, + uwg: s.uwg, + cwg: new(sync.WaitGroup), + bwg: new(sync.WaitGroup), + operateState: make(chan func(*pState)), + done: make(chan struct{}), + dlogger: log.New(s.debugOut, "[mpb] ", log.Lshortfile), + } + + p.cwg.Add(1) + go p.serve(s, cwriter.New(s.output)) + return p +} + +// AddBar creates a bar with default bar filler. Different filler can +// be choosen and applied via `*Progress.Add(...) *Bar` method. +func (p *Progress) AddBar(total int64, options ...BarOption) *Bar { + return p.Add(total, NewBarFiller(BarDefaultStyle), options...) +} + +// AddSpinner creates a bar with default spinner filler. Different +// filler can be choosen and applied via `*Progress.Add(...) *Bar` +// method. +func (p *Progress) AddSpinner(total int64, alignment SpinnerAlignment, options ...BarOption) *Bar { + return p.Add(total, NewSpinnerFiller(SpinnerDefaultStyle, alignment), options...) +} + +// Add creates a bar which renders itself by provided filler. +// If `total <= 0` trigger complete event is disabled until reset with *bar.SetTotal(int64, bool). +// Panics if *Progress instance is done, i.e. called after *Progress.Wait(). +func (p *Progress) Add(total int64, filler BarFiller, options ...BarOption) *Bar { + if filler == nil { + filler = BarFillerFunc(func(io.Writer, int, decor.Statistics) {}) + } + p.bwg.Add(1) + result := make(chan *Bar) + select { + case p.operateState <- func(ps *pState) { + bs := ps.makeBarState(total, filler, options...) + bar := newBar(p, bs) + if bs.runningBar != nil { + bs.runningBar.noPop = true + ps.parkedBars[bs.runningBar] = bar + } else { + heap.Push(&ps.bHeap, bar) + ps.heapUpdated = true + } + ps.idCount++ + result <- bar + }: + bar := <-result + bar.subscribeDecorators() + return bar + case <-p.done: + p.bwg.Done() + panic(fmt.Sprintf("%T instance can't be reused after it's done!", p)) + } +} + +func (p *Progress) dropBar(b *Bar) { + select { + case p.operateState <- func(s *pState) { + if b.index < 0 { + return + } + heap.Remove(&s.bHeap, b.index) + s.heapUpdated = true + }: + case <-p.done: + } +} + +func (p *Progress) setBarPriority(b *Bar, priority int) { + select { + case p.operateState <- func(s *pState) { + if b.index < 0 { + return + } + b.priority = priority + heap.Fix(&s.bHeap, b.index) + }: + case <-p.done: + } +} + +// UpdateBarPriority same as *Bar.SetPriority(int). +func (p *Progress) UpdateBarPriority(b *Bar, priority int) { + p.setBarPriority(b, priority) +} + +// BarCount returns bars count. +func (p *Progress) BarCount() int { + result := make(chan int, 1) + select { + case p.operateState <- func(s *pState) { result <- s.bHeap.Len() }: + return <-result + case <-p.done: + return 0 + } +} + +// Wait waits for all bars to complete and finally shutdowns container. +// After this method has been called, there is no way to reuse *Progress +// instance. +func (p *Progress) Wait() { + if p.uwg != nil { + // wait for user wg + p.uwg.Wait() + } + + // wait for bars to quit, if any + p.bwg.Wait() + + p.once.Do(p.shutdown) + + // wait for container to quit + p.cwg.Wait() +} + +func (p *Progress) shutdown() { + close(p.done) +} + +func (p *Progress) serve(s *pState, cw *cwriter.Writer) { + defer p.cwg.Done() + + p.refreshCh = s.newTicker(p.done) + + for { + select { + case op := <-p.operateState: + op(s) + case <-p.refreshCh: + if err := s.render(cw); err != nil { + p.dlogger.Println(err) + } + case <-s.shutdownNotifier: + if s.heapUpdated { + if err := s.render(cw); err != nil { + p.dlogger.Println(err) + } + } + return + } + } +} + +func (s *pState) newTicker(done <-chan struct{}) chan time.Time { + ch := make(chan time.Time) + if s.shutdownNotifier == nil { + s.shutdownNotifier = make(chan struct{}) + } + go func() { + if s.renderDelay != nil { + <-s.renderDelay + } + var internalRefresh <-chan time.Time + if !s.outputDiscarded { + if s.externalRefresh == nil { + ticker := time.NewTicker(s.rr) + defer ticker.Stop() + internalRefresh = ticker.C + } + } else { + s.externalRefresh = nil + } + for { + select { + case t := <-internalRefresh: + ch <- t + case x := <-s.externalRefresh: + if t, ok := x.(time.Time); ok { + ch <- t + } else { + ch <- time.Now() + } + case <-done: + close(s.shutdownNotifier) + return + } + } + }() + return ch +} + +func (s *pState) render(cw *cwriter.Writer) error { + if s.heapUpdated { + s.updateSyncMatrix() + s.heapUpdated = false + } + syncWidth(s.pMatrix) + syncWidth(s.aMatrix) + + tw, err := cw.GetWidth() + if err != nil { + tw = s.reqWidth + } + for i := 0; i < s.bHeap.Len(); i++ { + bar := s.bHeap[i] + go bar.render(tw) + } + + return s.flush(cw) +} + +func (s *pState) flush(cw *cwriter.Writer) error { + var lineCount int + bm := make(map[*Bar]struct{}, s.bHeap.Len()) + for s.bHeap.Len() > 0 { + b := heap.Pop(&s.bHeap).(*Bar) + cw.ReadFrom(<-b.frameCh) + if b.toShutdown { + if b.recoveredPanic != nil { + s.barShutdownQueue = append(s.barShutdownQueue, b) + b.toShutdown = false + } else { + // shutdown at next flush + // this ensures no bar ends up with less than 100% rendered + defer func() { + s.barShutdownQueue = append(s.barShutdownQueue, b) + }() + } + } + lineCount += b.extendedLines + 1 + bm[b] = struct{}{} + } + + for _, b := range s.barShutdownQueue { + if parkedBar := s.parkedBars[b]; parkedBar != nil { + parkedBar.priority = b.priority + heap.Push(&s.bHeap, parkedBar) + delete(s.parkedBars, b) + b.toDrop = true + } + if s.popCompleted && !b.noPop { + lineCount -= b.extendedLines + 1 + b.toDrop = true + } + if b.toDrop { + delete(bm, b) + s.heapUpdated = true + } + b.cancel() + } + s.barShutdownQueue = s.barShutdownQueue[0:0] + + for b := range bm { + heap.Push(&s.bHeap, b) + } + + return cw.Flush(lineCount) +} + +func (s *pState) updateSyncMatrix() { + s.pMatrix = make(map[int][]chan int) + s.aMatrix = make(map[int][]chan int) + for i := 0; i < s.bHeap.Len(); i++ { + bar := s.bHeap[i] + table := bar.wSyncTable() + pRow, aRow := table[0], table[1] + + for i, ch := range pRow { + s.pMatrix[i] = append(s.pMatrix[i], ch) + } + + for i, ch := range aRow { + s.aMatrix[i] = append(s.aMatrix[i], ch) + } + } +} + +func (s *pState) makeBarState(total int64, filler BarFiller, options ...BarOption) *bState { + bs := &bState{ + id: s.idCount, + priority: s.idCount, + reqWidth: s.reqWidth, + total: total, + filler: filler, + extender: func(r io.Reader, _ int, _ decor.Statistics) (io.Reader, int) { return r, 0 }, + debugOut: s.debugOut, + } + + if total > 0 { + bs.triggerComplete = true + } + + for _, opt := range options { + if opt != nil { + opt(bs) + } + } + + if bs.middleware != nil { + bs.filler = bs.middleware(filler) + bs.middleware = nil + } + + if s.popCompleted && !bs.noPop { + bs.priority = -(math.MaxInt32 - s.idCount) + } + + bs.bufP = bytes.NewBuffer(make([]byte, 0, 128)) + bs.bufB = bytes.NewBuffer(make([]byte, 0, 256)) + bs.bufA = bytes.NewBuffer(make([]byte, 0, 128)) + + return bs +} + +func syncWidth(matrix map[int][]chan int) { + for _, column := range matrix { + go maxWidthDistributor(column) + } +} + +var maxWidthDistributor = func(column []chan int) { + var maxWidth int + for _, ch := range column { + if w := <-ch; w > maxWidth { + maxWidth = w + } + } + for _, ch := range column { + ch <- maxWidth + } +} diff --git a/vendor/github.com/vbauerster/mpb/v6/proxyreader.go b/vendor/github.com/vbauerster/mpb/v6/proxyreader.go new file mode 100644 index 000000000..316f438d7 --- /dev/null +++ b/vendor/github.com/vbauerster/mpb/v6/proxyreader.go @@ -0,0 +1,90 @@ +package mpb + +import ( + "io" + "io/ioutil" + "time" +) + +type proxyReader struct { + io.ReadCloser + bar *Bar +} + +func (x *proxyReader) Read(p []byte) (int, error) { + n, err := x.ReadCloser.Read(p) + x.bar.IncrBy(n) + if err == io.EOF { + go x.bar.SetTotal(0, true) + } + return n, err +} + +type proxyWriterTo struct { + io.ReadCloser // *proxyReader + wt io.WriterTo + bar *Bar +} + +func (x *proxyWriterTo) WriteTo(w io.Writer) (int64, error) { + n, err := x.wt.WriteTo(w) + x.bar.IncrInt64(n) + if err == io.EOF { + go x.bar.SetTotal(0, true) + } + return n, err +} + +type ewmaProxyReader struct { + io.ReadCloser // *proxyReader + bar *Bar + iT time.Time +} + +func (x *ewmaProxyReader) Read(p []byte) (int, error) { + n, err := x.ReadCloser.Read(p) + if n > 0 { + x.bar.DecoratorEwmaUpdate(time.Since(x.iT)) + x.iT = time.Now() + } + return n, err +} + +type ewmaProxyWriterTo struct { + io.ReadCloser // *ewmaProxyReader + wt io.WriterTo // *proxyWriterTo + bar *Bar + iT time.Time +} + +func (x *ewmaProxyWriterTo) WriteTo(w io.Writer) (int64, error) { + n, err := x.wt.WriteTo(w) + if n > 0 { + x.bar.DecoratorEwmaUpdate(time.Since(x.iT)) + x.iT = time.Now() + } + return n, err +} + +func newProxyReader(r io.Reader, bar *Bar) io.ReadCloser { + rc := toReadCloser(r) + rc = &proxyReader{rc, bar} + + if wt, isWriterTo := r.(io.WriterTo); bar.hasEwmaDecorators { + now := time.Now() + rc = &ewmaProxyReader{rc, bar, now} + if isWriterTo { + rc = &ewmaProxyWriterTo{rc, wt, bar, now} + } + } else if isWriterTo { + rc = &proxyWriterTo{rc, wt, bar} + } + return rc +} + +func toReadCloser(r io.Reader) io.ReadCloser { + if rc, ok := r.(io.ReadCloser); ok { + return rc + } + return ioutil.NopCloser(r) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 32fb1b54a..eb58bd54f 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -240,12 +240,24 @@ github.com/coreos/go-systemd/v22/dbus github.com/coreos/go-systemd/v22/internal/dlopen github.com/coreos/go-systemd/v22/journal github.com/coreos/go-systemd/v22/sdjournal +# github.com/coreos/stream-metadata-go v0.0.0-20210225230131-70edb9eb47b3 +github.com/coreos/stream-metadata-go/fedoracoreos +github.com/coreos/stream-metadata-go/fedoracoreos/internals +github.com/coreos/stream-metadata-go/stream +github.com/coreos/stream-metadata-go/stream/rhcos # github.com/cri-o/ocicni v0.2.1-0.20210301205850-541cf7c703cf github.com/cri-o/ocicni/pkg/ocicni # github.com/cyphar/filepath-securejoin v0.2.2 github.com/cyphar/filepath-securejoin # github.com/davecgh/go-spew v1.1.1 github.com/davecgh/go-spew/spew +# github.com/digitalocean/go-libvirt v0.0.0-20201209184759-e2a69bcd5bd1 +github.com/digitalocean/go-libvirt +github.com/digitalocean/go-libvirt/internal/constants +github.com/digitalocean/go-libvirt/internal/event +github.com/digitalocean/go-libvirt/internal/go-xdr/xdr2 +# github.com/digitalocean/go-qemu v0.0.0-20210209191958-152a1535e49f +github.com/digitalocean/go-qemu/qmp # github.com/docker/distribution v2.7.1+incompatible github.com/docker/distribution github.com/docker/distribution/digestset @@ -572,6 +584,11 @@ github.com/vbauerster/mpb/v5 github.com/vbauerster/mpb/v5/cwriter github.com/vbauerster/mpb/v5/decor github.com/vbauerster/mpb/v5/internal +# github.com/vbauerster/mpb/v6 v6.0.2 +github.com/vbauerster/mpb/v6 +github.com/vbauerster/mpb/v6/cwriter +github.com/vbauerster/mpb/v6/decor +github.com/vbauerster/mpb/v6/internal # github.com/vishvananda/netlink v1.1.1-0.20201029203352-d40f9887b852 github.com/vishvananda/netlink github.com/vishvananda/netlink/nl |