diff options
Diffstat (limited to 'vendor/github.com/dmacvicar')
17 files changed, 4218 insertions, 0 deletions
diff --git a/vendor/github.com/dmacvicar/libvirt-go/LICENSE b/vendor/github.com/dmacvicar/libvirt-go/LICENSE new file mode 100644 index 00000000..202f5fce --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/LICENSE @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2013 Alex Zorin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +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 OR COPYRIGHT HOLDERS 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.
\ No newline at end of file diff --git a/vendor/github.com/dmacvicar/libvirt-go/README.md b/vendor/github.com/dmacvicar/libvirt-go/README.md new file mode 100644 index 00000000..814bd673 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/README.md @@ -0,0 +1,49 @@ +# libvirt-go + +[](http://ci.serversaurus.com/github.com/alexzorin/libvirt-go) + +Go bindings for libvirt. + +Make sure to have `libvirt-dev` package (or the development files otherwise somewhere in your include path) + +## Version Support +Currently, the only supported version of libvirt is **1.2.2**, tagged as `v2.x` releases `gopkg.in/alexzorin/libvirt-go.v2` [(docs)](http://gopkg.in/alexzorin/libvirt-go.v2). + +The bindings will probably work with versions of libvirt that are higher than 1.2.2, depending on what is added in those releases. However, no features are currently being added that will cause the build or tests to break against 1.2.2. + +### OS Compatibility Matrix + +To quickly see what version of libvirt your OS can easily support (may be outdated). Obviously, nothing below 1.2.2 is usable with these bindings. + +| OS Release | libvirt Version | +| ------------ | ------------------------------ | +| FC19 | 1.2.9 from libvirt.org/sources | +| Debian 7 | 1.2.4 from wheezy-backports | +| Debian 6 | 0.9.12 from squeeze-backports | +| Ubuntu 14.04 | 1.2.2 from trusty | +| RHEL 6 | 0.10.x | +| RHEL 5 | 0.8.x | + + +### 0.9.x Support + +Previously there was support for libvirt 0.9.8 and below, however this is no longer being updated. These releases were tagged `v1.x` at `gopkg.in/alexzorin/libvirt-go.v1` [(docs)](http://gopkg.in/alexzorin/libvirt-go.v1). + +## Documentation + +* [api documentation for the bindings](http://godoc.org/github.com/rgbkrk/libvirt-go) +* [api documentation for libvirt](http://libvirt.org/html/libvirt-libvirt.html) + +## Contributing + +Please fork and write tests. + +Integration tests are available where functionality isn't provided by the test driver, see `integration_test.go`. + +A `Vagrantfile` is included to run the integration tests: + +* `cd ./vagrant/{branch}` (i.e `./vagrant/master`, where you will find a `Vagrantfile` for the `master` branch) +* `vagrant up` to provision the virtual machine +* `vagrant ssh` to login to the virtual machine + +Once inside, `sudo su -`, `cd /libvirt-go` and `go test -tags integration`. diff --git a/vendor/github.com/dmacvicar/libvirt-go/cfuncs.go b/vendor/github.com/dmacvicar/libvirt-go/cfuncs.go new file mode 100644 index 00000000..b099026e --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/cfuncs.go @@ -0,0 +1,109 @@ +package libvirt + +/* + * Golang 1.6 doesn't support C pointers to go memory. + * A hacky-solution might be some multi-threaded approach to support domain events, but let's make it work + * without domain events for now. + */ + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> + +int domainEventLifecycleCallback_cgo(virConnectPtr c, virDomainPtr d, + int event, int detail, void *data) +{ + return domainEventLifecycleCallback(c, d, event, detail, data); +} + +int domainEventGenericCallback_cgo(virConnectPtr c, virDomainPtr d, void *data) +{ + return domainEventGenericCallback(c, d, data); +} + +int domainEventRTCChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + long long utcoffset, void *data) +{ + return domainEventRTCChangeCallback(c, d, utcoffset, data); +} + +int domainEventWatchdogCallback_cgo(virConnectPtr c, virDomainPtr d, + int action, void *data) +{ + return domainEventWatchdogCallback(c, d, action, data); +} + +int domainEventIOErrorCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *srcPath, const char *devAlias, + int action, void *data) +{ + return domainEventIOErrorCallback(c, d, srcPath, devAlias, action, data); +} + +int domainEventGraphicsCallback_cgo(virConnectPtr c, virDomainPtr d, + int phase, const virDomainEventGraphicsAddress *local, + const virDomainEventGraphicsAddress *remote, + const char *authScheme, + const virDomainEventGraphicsSubject *subject, void *data) +{ + return domainEventGraphicsCallback(c, d, phase, local, remote, authScheme, subject, data); +} + +int domainEventIOErrorReasonCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *srcPath, const char *devAlias, + int action, const char *reason, void *data) +{ + return domainEventIOErrorReasonCallback(c, d, srcPath, devAlias, action, reason, data); +} + +int domainEventBlockJobCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *disk, int type, int status, void *data) +{ + return domainEventIOErrorReasonCallback(c, d, disk, type, status, data); +} + +int domainEventDiskChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *oldSrcPath, const char *newSrcPath, + const char *devAlias, int reason, void *data) +{ + return domainEventDiskChangeCallback(c, d, oldSrcPath, newSrcPath, devAlias, reason, data); +} + +int domainEventTrayChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *devAlias, int reason, void *data) +{ + return domainEventTrayChangeCallback(c, d, devAlias, reason, data); +} + +int domainEventReasonCallback_cgo(virConnectPtr c, virDomainPtr d, + int reason, void *data) +{ + return domainEventReasonCallback(c, d, reason, data); +} + +int domainEventBalloonChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + unsigned long long actual, void *data) +{ + return domainEventBalloonChangeCallback(c, d, actual, data); +} + +int domainEventDeviceRemovedCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *devAlias, void *data) +{ + return domainEventDeviceRemovedCallback(c, d, devAlias, data); +} + +void freeGoCallback_cgo(void* goCallbackId) { + freeCallbackId((size_t)goCallbackId); +} + +int virConnectDomainEventRegisterAny_cgo(virConnectPtr c, virDomainPtr d, + int eventID, virConnectDomainEventGenericCallback cb, + int goCallbackId) { + void* id = (void*)0 + goCallbackId; // Hack to silence the warning + return virConnectDomainEventRegisterAny(c, d, eventID, cb, id, freeGoCallback_cgo); +} +*/ +import "C" diff --git a/vendor/github.com/dmacvicar/libvirt-go/constants.go b/vendor/github.com/dmacvicar/libvirt-go/constants.go new file mode 100644 index 00000000..dce5cba8 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/constants.go @@ -0,0 +1,473 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +// virDomainState +const ( + VIR_DOMAIN_NOSTATE = C.VIR_DOMAIN_NOSTATE + VIR_DOMAIN_RUNNING = C.VIR_DOMAIN_RUNNING + VIR_DOMAIN_BLOCKED = C.VIR_DOMAIN_BLOCKED + VIR_DOMAIN_PAUSED = C.VIR_DOMAIN_PAUSED + VIR_DOMAIN_SHUTDOWN = C.VIR_DOMAIN_SHUTDOWN + VIR_DOMAIN_CRASHED = C.VIR_DOMAIN_CRASHED + VIR_DOMAIN_PMSUSPENDED = C.VIR_DOMAIN_PMSUSPENDED + VIR_DOMAIN_SHUTOFF = C.VIR_DOMAIN_SHUTOFF +) + +//virConnectListAllDomainsFlags +const ( + VIR_CONNECT_LIST_DOMAINS_ACTIVE = C.VIR_CONNECT_LIST_DOMAINS_ACTIVE + VIR_CONNECT_LIST_DOMAINS_INACTIVE = C.VIR_CONNECT_LIST_DOMAINS_INACTIVE + VIR_CONNECT_LIST_DOMAINS_PERSISTENT = C.VIR_CONNECT_LIST_DOMAINS_PERSISTENT + VIR_CONNECT_LIST_DOMAINS_TRANSIENT = C.VIR_CONNECT_LIST_DOMAINS_TRANSIENT + VIR_CONNECT_LIST_DOMAINS_RUNNING = C.VIR_CONNECT_LIST_DOMAINS_RUNNING + VIR_CONNECT_LIST_DOMAINS_PAUSED = C.VIR_CONNECT_LIST_DOMAINS_PAUSED + VIR_CONNECT_LIST_DOMAINS_SHUTOFF = C.VIR_CONNECT_LIST_DOMAINS_SHUTOFF + VIR_CONNECT_LIST_DOMAINS_OTHER = C.VIR_CONNECT_LIST_DOMAINS_OTHER + VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE = C.VIR_CONNECT_LIST_DOMAINS_MANAGEDSAVE + VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE = C.VIR_CONNECT_LIST_DOMAINS_NO_MANAGEDSAVE + VIR_CONNECT_LIST_DOMAINS_AUTOSTART = C.VIR_CONNECT_LIST_DOMAINS_AUTOSTART + VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART = C.VIR_CONNECT_LIST_DOMAINS_NO_AUTOSTART + VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT = C.VIR_CONNECT_LIST_DOMAINS_HAS_SNAPSHOT + VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT = C.VIR_CONNECT_LIST_DOMAINS_NO_SNAPSHOT +) + +// virDomainMetadataType +const ( + VIR_DOMAIN_METADATA_DESCRIPTION = C.VIR_DOMAIN_METADATA_DESCRIPTION + VIR_DOMAIN_METADATA_TITLE = C.VIR_DOMAIN_METADATA_TITLE + VIR_DOMAIN_METADATA_ELEMENT = C.VIR_DOMAIN_METADATA_ELEMENT +) + +// virDomainVcpuFlags +const ( + VIR_DOMAIN_VCPU_CONFIG = C.VIR_DOMAIN_VCPU_CONFIG + VIR_DOMAIN_VCPU_CURRENT = C.VIR_DOMAIN_VCPU_CURRENT + VIR_DOMAIN_VCPU_LIVE = C.VIR_DOMAIN_VCPU_LIVE + VIR_DOMAIN_VCPU_MAXIMUM = C.VIR_DOMAIN_VCPU_MAXIMUM + VIR_DOMAIN_VCPU_GUEST = C.VIR_DOMAIN_VCPU_GUEST +) + +// virDomainModificationImpact +const ( + VIR_DOMAIN_AFFECT_CONFIG = C.VIR_DOMAIN_AFFECT_CONFIG + VIR_DOMAIN_AFFECT_CURRENT = C.VIR_DOMAIN_AFFECT_CURRENT + VIR_DOMAIN_AFFECT_LIVE = C.VIR_DOMAIN_AFFECT_LIVE +) + +// virDomainMemoryModFlags +const ( + VIR_DOMAIN_MEM_CONFIG = C.VIR_DOMAIN_AFFECT_CONFIG + VIR_DOMAIN_MEM_CURRENT = C.VIR_DOMAIN_AFFECT_CURRENT + VIR_DOMAIN_MEM_LIVE = C.VIR_DOMAIN_AFFECT_LIVE + VIR_DOMAIN_MEM_MAXIMUM = C.VIR_DOMAIN_MEM_MAXIMUM +) + +// virStoragePoolState +const ( + VIR_STORAGE_POOL_INACTIVE = C.VIR_STORAGE_POOL_INACTIVE // Not running + VIR_STORAGE_POOL_BUILDING = C.VIR_STORAGE_POOL_BUILDING // Initializing pool,not available + VIR_STORAGE_POOL_RUNNING = C.VIR_STORAGE_POOL_RUNNING // Running normally + VIR_STORAGE_POOL_DEGRADED = C.VIR_STORAGE_POOL_DEGRADED // Running degraded + VIR_STORAGE_POOL_INACCESSIBLE = C.VIR_STORAGE_POOL_INACCESSIBLE // Running,but not accessible +) + +// virStoragePoolBuildFlags +const ( + VIR_STORAGE_POOL_BUILD_NEW = C.VIR_STORAGE_POOL_BUILD_NEW // Regular build from scratch + VIR_STORAGE_POOL_BUILD_REPAIR = C.VIR_STORAGE_POOL_BUILD_REPAIR // Repair / reinitialize + VIR_STORAGE_POOL_BUILD_RESIZE = C.VIR_STORAGE_POOL_BUILD_RESIZE // Extend existing pool + VIR_STORAGE_POOL_BUILD_NO_OVERWRITE = C.VIR_STORAGE_POOL_BUILD_NO_OVERWRITE // Do not overwrite existing pool + VIR_STORAGE_POOL_BUILD_OVERWRITE = C.VIR_STORAGE_POOL_BUILD_OVERWRITE // Overwrite data +) + +// virDomainDestroyFlags +const ( + VIR_DOMAIN_DESTROY_DEFAULT = C.VIR_DOMAIN_DESTROY_DEFAULT + VIR_DOMAIN_DESTROY_GRACEFUL = C.VIR_DOMAIN_DESTROY_GRACEFUL +) + +// virDomainShutdownFlags +const ( + VIR_DOMAIN_SHUTDOWN_DEFAULT = C.VIR_DOMAIN_SHUTDOWN_DEFAULT + VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN = C.VIR_DOMAIN_SHUTDOWN_ACPI_POWER_BTN + VIR_DOMAIN_SHUTDOWN_GUEST_AGENT = C.VIR_DOMAIN_SHUTDOWN_GUEST_AGENT + VIR_DOMAIN_SHUTDOWN_INITCTL = C.VIR_DOMAIN_SHUTDOWN_INITCTL + VIR_DOMAIN_SHUTDOWN_SIGNAL = C.VIR_DOMAIN_SHUTDOWN_SIGNAL +) + +// virDomainUndefineFlags +const ( + VIR_DOMAIN_UNDEFINE_DEFAULT = 0 + VIR_DOMAIN_UNDEFINE_MANAGED_SAVE = C.VIR_DOMAIN_UNDEFINE_MANAGED_SAVE + VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA = C.VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA + VIR_DOMAIN_UNDEFINE_NVRAM = C.VIR_DOMAIN_UNDEFINE_NVRAM +) + +// virDomainAttachDeviceFlags +const ( + VIR_DOMAIN_DEVICE_MODIFY_CONFIG = C.VIR_DOMAIN_AFFECT_CONFIG + VIR_DOMAIN_DEVICE_MODIFY_CURRENT = C.VIR_DOMAIN_AFFECT_CURRENT + VIR_DOMAIN_DEVICE_MODIFY_LIVE = C.VIR_DOMAIN_AFFECT_LIVE + VIR_DOMAIN_DEVICE_MODIFY_FORCE = C.VIR_DOMAIN_DEVICE_MODIFY_FORCE +) + +// virStorageVolCreateFlags +const ( + VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA = C.VIR_STORAGE_VOL_CREATE_PREALLOC_METADATA +) + +// virStorageVolDeleteFlags +const ( + VIR_STORAGE_VOL_DELETE_NORMAL = C.VIR_STORAGE_VOL_DELETE_NORMAL // Delete metadata only (fast) + VIR_STORAGE_VOL_DELETE_ZEROED = C.VIR_STORAGE_VOL_DELETE_ZEROED // Clear all data to zeros (slow) +) + +// virStorageVolResizeFlags +const ( + VIR_STORAGE_VOL_RESIZE_ALLOCATE = C.VIR_STORAGE_VOL_RESIZE_ALLOCATE // force allocation of new size + VIR_STORAGE_VOL_RESIZE_DELTA = C.VIR_STORAGE_VOL_RESIZE_DELTA // size is relative to current + VIR_STORAGE_VOL_RESIZE_SHRINK = C.VIR_STORAGE_VOL_RESIZE_SHRINK // allow decrease in capacity +) + +// virStorageVolType +const ( + VIR_STORAGE_VOL_FILE = C.VIR_STORAGE_VOL_FILE // Regular file based volumes + VIR_STORAGE_VOL_BLOCK = C.VIR_STORAGE_VOL_BLOCK // Block based volumes + VIR_STORAGE_VOL_DIR = C.VIR_STORAGE_VOL_DIR // Directory-passthrough based volume + VIR_STORAGE_VOL_NETWORK = C.VIR_STORAGE_VOL_NETWORK //Network volumes like RBD (RADOS Block Device) + VIR_STORAGE_VOL_NETDIR = C.VIR_STORAGE_VOL_NETDIR // Network accessible directory that can contain other network volumes +) + +// virStorageVolWipeAlgorithm +const ( + VIR_STORAGE_VOL_WIPE_ALG_ZERO = C.VIR_STORAGE_VOL_WIPE_ALG_ZERO // 1-pass, all zeroes + VIR_STORAGE_VOL_WIPE_ALG_NNSA = C.VIR_STORAGE_VOL_WIPE_ALG_NNSA // 4-pass NNSA Policy Letter NAP-14.1-C (XVI-8) + VIR_STORAGE_VOL_WIPE_ALG_DOD = C.VIR_STORAGE_VOL_WIPE_ALG_DOD // 4-pass DoD 5220.22-M section 8-306 procedure + VIR_STORAGE_VOL_WIPE_ALG_BSI = C.VIR_STORAGE_VOL_WIPE_ALG_BSI // 9-pass method recommended by the German Center of Security in Information Technologies + VIR_STORAGE_VOL_WIPE_ALG_GUTMANN = C.VIR_STORAGE_VOL_WIPE_ALG_GUTMANN // The canonical 35-pass sequence + VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER = C.VIR_STORAGE_VOL_WIPE_ALG_SCHNEIER // 7-pass method described by Bruce Schneier in "Applied Cryptography" (1996) + VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 = C.VIR_STORAGE_VOL_WIPE_ALG_PFITZNER7 // 7-pass random + VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 = C.VIR_STORAGE_VOL_WIPE_ALG_PFITZNER33 // 33-pass random + VIR_STORAGE_VOL_WIPE_ALG_RANDOM = C.VIR_STORAGE_VOL_WIPE_ALG_RANDOM // 1-pass random +) + +// virSecretUsageType +const ( + VIR_SECRET_USAGE_TYPE_NONE = C.VIR_SECRET_USAGE_TYPE_NONE + VIR_SECRET_USAGE_TYPE_VOLUME = C.VIR_SECRET_USAGE_TYPE_VOLUME + VIR_SECRET_USAGE_TYPE_CEPH = C.VIR_SECRET_USAGE_TYPE_CEPH + VIR_SECRET_USAGE_TYPE_ISCSI = C.VIR_SECRET_USAGE_TYPE_ISCSI +) + +// virConnectListAllNetworksFlags +const ( + VIR_CONNECT_LIST_NETWORKS_INACTIVE = C.VIR_CONNECT_LIST_NETWORKS_INACTIVE + VIR_CONNECT_LIST_NETWORKS_ACTIVE = C.VIR_CONNECT_LIST_NETWORKS_ACTIVE + VIR_CONNECT_LIST_NETWORKS_PERSISTENT = C.VIR_CONNECT_LIST_NETWORKS_PERSISTENT + VIR_CONNECT_LIST_NETWORKS_TRANSIENT = C.VIR_CONNECT_LIST_NETWORKS_TRANSIENT + VIR_CONNECT_LIST_NETWORKS_AUTOSTART = C.VIR_CONNECT_LIST_NETWORKS_AUTOSTART + VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART = C.VIR_CONNECT_LIST_NETWORKS_NO_AUTOSTART +) + +// virConnectListAllStoragePoolsFlags +const ( + VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE = C.VIR_CONNECT_LIST_STORAGE_POOLS_INACTIVE + VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE = C.VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE + VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT = C.VIR_CONNECT_LIST_STORAGE_POOLS_PERSISTENT + VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT = C.VIR_CONNECT_LIST_STORAGE_POOLS_TRANSIENT + VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART = C.VIR_CONNECT_LIST_STORAGE_POOLS_AUTOSTART + VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART = C.VIR_CONNECT_LIST_STORAGE_POOLS_NO_AUTOSTART + VIR_CONNECT_LIST_STORAGE_POOLS_DIR = C.VIR_CONNECT_LIST_STORAGE_POOLS_DIR + VIR_CONNECT_LIST_STORAGE_POOLS_FS = C.VIR_CONNECT_LIST_STORAGE_POOLS_FS + VIR_CONNECT_LIST_STORAGE_POOLS_NETFS = C.VIR_CONNECT_LIST_STORAGE_POOLS_NETFS + VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL = C.VIR_CONNECT_LIST_STORAGE_POOLS_LOGICAL + VIR_CONNECT_LIST_STORAGE_POOLS_DISK = C.VIR_CONNECT_LIST_STORAGE_POOLS_DISK + VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI = C.VIR_CONNECT_LIST_STORAGE_POOLS_ISCSI + VIR_CONNECT_LIST_STORAGE_POOLS_SCSI = C.VIR_CONNECT_LIST_STORAGE_POOLS_SCSI + VIR_CONNECT_LIST_STORAGE_POOLS_MPATH = C.VIR_CONNECT_LIST_STORAGE_POOLS_MPATH + VIR_CONNECT_LIST_STORAGE_POOLS_RBD = C.VIR_CONNECT_LIST_STORAGE_POOLS_RBD + VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG = C.VIR_CONNECT_LIST_STORAGE_POOLS_SHEEPDOG + VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER = C.VIR_CONNECT_LIST_STORAGE_POOLS_GLUSTER +) + +// virStreamFlags +const ( + VIR_STREAM_NONBLOCK = C.VIR_STREAM_NONBLOCK +) + +// virKeycodeSet +const ( + VIR_KEYCODE_SET_LINUX = C.VIR_KEYCODE_SET_LINUX + VIR_KEYCODE_SET_XT = C.VIR_KEYCODE_SET_XT + VIR_KEYCODE_SET_ATSET1 = C.VIR_KEYCODE_SET_ATSET1 + VIR_KEYCODE_SET_ATSET2 = C.VIR_KEYCODE_SET_ATSET2 + VIR_KEYCODE_SET_ATSET3 = C.VIR_KEYCODE_SET_ATSET3 + VIR_KEYCODE_SET_OSX = C.VIR_KEYCODE_SET_OSX + VIR_KEYCODE_SET_XT_KBD = C.VIR_KEYCODE_SET_XT_KBD + VIR_KEYCODE_SET_USB = C.VIR_KEYCODE_SET_USB + VIR_KEYCODE_SET_WIN32 = C.VIR_KEYCODE_SET_WIN32 + VIR_KEYCODE_SET_RFB = C.VIR_KEYCODE_SET_RFB +) + +// virDomainCreateFlags +const ( + VIR_DOMAIN_NONE = C.VIR_DOMAIN_NONE + VIR_DOMAIN_START_PAUSED = C.VIR_DOMAIN_START_PAUSED + VIR_DOMAIN_START_AUTODESTROY = C.VIR_DOMAIN_START_AUTODESTROY + VIR_DOMAIN_START_BYPASS_CACHE = C.VIR_DOMAIN_START_BYPASS_CACHE + VIR_DOMAIN_START_FORCE_BOOT = C.VIR_DOMAIN_START_FORCE_BOOT +) + +const VIR_DOMAIN_MEMORY_PARAM_UNLIMITED = C.VIR_DOMAIN_MEMORY_PARAM_UNLIMITED + +// virDomainEventID +const ( + // event parameter in the callback is of type DomainLifecycleEvent + VIR_DOMAIN_EVENT_ID_LIFECYCLE = C.VIR_DOMAIN_EVENT_ID_LIFECYCLE + + // event parameter in the callback is nil + VIR_DOMAIN_EVENT_ID_REBOOT = C.VIR_DOMAIN_EVENT_ID_REBOOT + + // event parameter in the callback is of type DomainRTCChangeEvent + VIR_DOMAIN_EVENT_ID_RTC_CHANGE = C.VIR_DOMAIN_EVENT_ID_RTC_CHANGE + + // event parameter in the callback is of type DomainWatchdogEvent + VIR_DOMAIN_EVENT_ID_WATCHDOG = C.VIR_DOMAIN_EVENT_ID_WATCHDOG + + // event parameter in the callback is of type DomainIOErrorEvent + VIR_DOMAIN_EVENT_ID_IO_ERROR = C.VIR_DOMAIN_EVENT_ID_IO_ERROR + + // event parameter in the callback is of type DomainGraphicsEvent + VIR_DOMAIN_EVENT_ID_GRAPHICS = C.VIR_DOMAIN_EVENT_ID_GRAPHICS + + // virConnectDomainEventIOErrorReasonCallback + VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON = C.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON + + // event parameter in the callback is nil + VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = C.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR + + // event parameter in the callback is of type DomainBlockJobEvent + VIR_DOMAIN_EVENT_ID_BLOCK_JOB = C.VIR_DOMAIN_EVENT_ID_BLOCK_JOB + + // event parameter in the callback is of type DomainDiskChangeEvent + VIR_DOMAIN_EVENT_ID_DISK_CHANGE = C.VIR_DOMAIN_EVENT_ID_DISK_CHANGE + + // event parameter in the callback is of type DomainTrayChangeEvent + VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = C.VIR_DOMAIN_EVENT_ID_TRAY_CHANGE + + // event parameter in the callback is of type DomainReasonEvent + VIR_DOMAIN_EVENT_ID_PMWAKEUP = C.VIR_DOMAIN_EVENT_ID_PMWAKEUP + + // event parameter in the callback is of type DomainReasonEvent + VIR_DOMAIN_EVENT_ID_PMSUSPEND = C.VIR_DOMAIN_EVENT_ID_PMSUSPEND + + // event parameter in the callback is of type DomainBalloonChangeEvent + VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE = C.VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE + + // event parameter in the callback is of type DomainReasonEvent + VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK = C.VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK + + // event parameter in the callback is of type DomainDeviceRemovedEvent + VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED = C.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED + + // TODO Post 1.2.4, enable later + // event parameter in the callback is of type DomainBlockJobEvent + // VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 = C.VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2 +) + +// virDomainEventType +const ( + VIR_DOMAIN_EVENT_DEFINED = C.VIR_DOMAIN_EVENT_DEFINED + VIR_DOMAIN_EVENT_UNDEFINED = C.VIR_DOMAIN_EVENT_UNDEFINED + VIR_DOMAIN_EVENT_STARTED = C.VIR_DOMAIN_EVENT_STARTED + VIR_DOMAIN_EVENT_SUSPENDED = C.VIR_DOMAIN_EVENT_SUSPENDED + VIR_DOMAIN_EVENT_RESUMED = C.VIR_DOMAIN_EVENT_RESUMED + VIR_DOMAIN_EVENT_STOPPED = C.VIR_DOMAIN_EVENT_STOPPED + VIR_DOMAIN_EVENT_SHUTDOWN = C.VIR_DOMAIN_EVENT_SHUTDOWN + VIR_DOMAIN_EVENT_PMSUSPENDED = C.VIR_DOMAIN_EVENT_PMSUSPENDED + VIR_DOMAIN_EVENT_CRASHED = C.VIR_DOMAIN_EVENT_CRASHED +) + +// virDomainEventWatchdogAction: +// The action that is to be taken due to the watchdog device firing +const ( + // No action, watchdog ignored + VIR_DOMAIN_EVENT_WATCHDOG_NONE = C.VIR_DOMAIN_EVENT_WATCHDOG_NONE + + // Guest CPUs are paused + VIR_DOMAIN_EVENT_WATCHDOG_PAUSE = C.VIR_DOMAIN_EVENT_WATCHDOG_PAUSE + + // Guest CPUs are reset + VIR_DOMAIN_EVENT_WATCHDOG_RESET = C.VIR_DOMAIN_EVENT_WATCHDOG_RESET + + // Guest is forcibly powered off + VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF = C.VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF + + // Guest is requested to gracefully shutdown + VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN = C.VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN + + // No action, a debug message logged + VIR_DOMAIN_EVENT_WATCHDOG_DEBUG = C.VIR_DOMAIN_EVENT_WATCHDOG_DEBUG +) + +// virDomainEventIOErrorAction +// The action that is to be taken due to an IO error occurring +const ( + // No action, IO error ignored + VIR_DOMAIN_EVENT_IO_ERROR_NONE = C.VIR_DOMAIN_EVENT_IO_ERROR_NONE + + // Guest CPUs are paused + VIR_DOMAIN_EVENT_IO_ERROR_PAUSE = C.VIR_DOMAIN_EVENT_IO_ERROR_PAUSE + + // IO error reported to guest OS + VIR_DOMAIN_EVENT_IO_ERROR_REPORT = C.VIR_DOMAIN_EVENT_IO_ERROR_REPORT +) + +// virDomainEventGraphicsPhase +// The phase of the graphics client connection +const ( + // Initial socket connection established + VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = C.VIR_DOMAIN_EVENT_GRAPHICS_CONNECT + + // Authentication & setup completed + VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE = C.VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE + + // Final socket disconnection + VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT = C.VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT +) + +// virDomainEventGraphicsAddressType +const ( + // IPv4 address + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 = C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4 + + // IPv6 address + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 = C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6 + + // UNIX socket path + VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX = C.VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_UNIX +) + +// virDomainBlockJobType +const ( + // Placeholder + VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN = C.VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN + + // Block Pull (virDomainBlockPull, or virDomainBlockRebase without + // flags), job ends on completion + VIR_DOMAIN_BLOCK_JOB_TYPE_PULL = C.VIR_DOMAIN_BLOCK_JOB_TYPE_PULL + + // Block Copy (virDomainBlockCopy, or virDomainBlockRebase with + // flags), job exists as long as mirroring is active + VIR_DOMAIN_BLOCK_JOB_TYPE_COPY = C.VIR_DOMAIN_BLOCK_JOB_TYPE_COPY + + // Block Commit (virDomainBlockCommit without flags), job ends on + // completion + VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT = C.VIR_DOMAIN_BLOCK_JOB_TYPE_COMMIT + + // TODO Post 1.2.4, enable later + // Active Block Commit (virDomainBlockCommit with flags), job + // exists as long as sync is active + // VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT = C.VIR_DOMAIN_BLOCK_JOB_TYPE_ACTIVE_COMMIT +) + +// virConnectDomainEventBlockJobStatus +const ( + VIR_DOMAIN_BLOCK_JOB_COMPLETED = C.VIR_DOMAIN_BLOCK_JOB_COMPLETED + VIR_DOMAIN_BLOCK_JOB_FAILED = C.VIR_DOMAIN_BLOCK_JOB_FAILED + VIR_DOMAIN_BLOCK_JOB_CANCELED = C.VIR_DOMAIN_BLOCK_JOB_CANCELED + VIR_DOMAIN_BLOCK_JOB_READY = C.VIR_DOMAIN_BLOCK_JOB_READY +) + +// virConnectDomainEventDiskChangeReason +const ( + // OldSrcPath is set + VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START = C.VIR_DOMAIN_EVENT_DISK_CHANGE_MISSING_ON_START + VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START = C.VIR_DOMAIN_EVENT_DISK_DROP_MISSING_ON_START +) + +// virConnectDomainEventTrayChangeReason +const ( + VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN = C.VIR_DOMAIN_EVENT_TRAY_CHANGE_OPEN + VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE = C.VIR_DOMAIN_EVENT_TRAY_CHANGE_CLOSE +) + +// virDomainRunningReason +const ( + VIR_DOMAIN_RUNNING_UNKNOWN = C.VIR_DOMAIN_RUNNING_UNKNOWN + VIR_DOMAIN_RUNNING_BOOTED = C.VIR_DOMAIN_RUNNING_BOOTED /* normal startup from boot */ + VIR_DOMAIN_RUNNING_MIGRATED = C.VIR_DOMAIN_RUNNING_MIGRATED /* migrated from another host */ + VIR_DOMAIN_RUNNING_RESTORED = C.VIR_DOMAIN_RUNNING_RESTORED /* restored from a state file */ + VIR_DOMAIN_RUNNING_FROM_SNAPSHOT = C.VIR_DOMAIN_RUNNING_FROM_SNAPSHOT /* restored from snapshot */ + VIR_DOMAIN_RUNNING_UNPAUSED = C.VIR_DOMAIN_RUNNING_UNPAUSED /* returned from paused state */ + VIR_DOMAIN_RUNNING_MIGRATION_CANCELED = C.VIR_DOMAIN_RUNNING_MIGRATION_CANCELED /* returned from migration */ + VIR_DOMAIN_RUNNING_SAVE_CANCELED = C.VIR_DOMAIN_RUNNING_SAVE_CANCELED /* returned from failed save process */ + VIR_DOMAIN_RUNNING_WAKEUP = C.VIR_DOMAIN_RUNNING_WAKEUP /* returned from pmsuspended due to wakeup event */ + VIR_DOMAIN_RUNNING_CRASHED = C.VIR_DOMAIN_RUNNING_CRASHED /* resumed from crashed */ +) + +// virDomainPausedReason +const ( + VIR_DOMAIN_PAUSED_UNKNOWN = C.VIR_DOMAIN_PAUSED_UNKNOWN /* the reason is unknown */ + VIR_DOMAIN_PAUSED_USER = C.VIR_DOMAIN_PAUSED_USER /* paused on user request */ + VIR_DOMAIN_PAUSED_MIGRATION = C.VIR_DOMAIN_PAUSED_MIGRATION /* paused for offline migration */ + VIR_DOMAIN_PAUSED_SAVE = C.VIR_DOMAIN_PAUSED_SAVE /* paused for save */ + VIR_DOMAIN_PAUSED_DUMP = C.VIR_DOMAIN_PAUSED_DUMP /* paused for offline core dump */ + VIR_DOMAIN_PAUSED_IOERROR = C.VIR_DOMAIN_PAUSED_IOERROR /* paused due to a disk I/O error */ + VIR_DOMAIN_PAUSED_WATCHDOG = C.VIR_DOMAIN_PAUSED_WATCHDOG /* paused due to a watchdog event */ + VIR_DOMAIN_PAUSED_FROM_SNAPSHOT = C.VIR_DOMAIN_PAUSED_FROM_SNAPSHOT /* paused after restoring from snapshot */ + VIR_DOMAIN_PAUSED_SHUTTING_DOWN = C.VIR_DOMAIN_PAUSED_SHUTTING_DOWN /* paused during shutdown process */ + VIR_DOMAIN_PAUSED_SNAPSHOT = C.VIR_DOMAIN_PAUSED_SNAPSHOT /* paused while creating a snapshot */ + VIR_DOMAIN_PAUSED_CRASHED = C.VIR_DOMAIN_PAUSED_CRASHED /* paused due to a guest crash */ +) + +// virDomainXMLFlags +const ( + VIR_DOMAIN_XML_SECURE = C.VIR_DOMAIN_XML_SECURE /* dump security sensitive information too */ + VIR_DOMAIN_XML_INACTIVE = C.VIR_DOMAIN_XML_INACTIVE /* dump inactive domain information */ + VIR_DOMAIN_XML_UPDATE_CPU = C.VIR_DOMAIN_XML_UPDATE_CPU /* update guest CPU requirements according to host CPU */ + VIR_DOMAIN_XML_MIGRATABLE = C.VIR_DOMAIN_XML_MIGRATABLE /* dump XML suitable for migration */ +) + +/* + * QMP has two different kinds of ways to talk to QEMU. One is legacy (HMP, + * or 'human' monitor protocol. The default is QMP, which is all-JSON. + * + * QMP json commands are of the format: + * {"execute" : "query-cpus"} + * + * whereas the same command in 'HMP' would be: + * 'info cpus' + */ +const ( + VIR_DOMAIN_QEMU_MONITOR_COMMAND_DEFAULT = 0 + VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP = (1 << 0) +) + +// virDomainInterfaceAddressesSource +const ( + VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE = 0 + VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT = 1 +) + +// virIPAddrType +const ( + VIR_IP_ADDR_TYPE_IPV4 = 0 + VIR_IP_ADDR_TYPE_IPV6 = 1 +) + +// virDomainQemuAgentCommandTimeoutValues +const ( + VIR_DOMAIN_QEMU_AGENT_COMMAND_MIN = -2 + VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK = -2 + VIR_DOMAIN_QEMU_AGENT_COMMAND_DEFAULT = -1 + VIR_DOMAIN_QEMU_AGENT_COMMAND_NOWAIT = 0 + VIR_DOMAIN_QEMU_AGENT_COMMAND_SHUTDOWN = 60 +) diff --git a/vendor/github.com/dmacvicar/libvirt-go/domain.go b/vendor/github.com/dmacvicar/libvirt-go/domain.go new file mode 100644 index 00000000..227a9bac --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/domain.go @@ -0,0 +1,784 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt-qemu -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/libvirt-qemu.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "reflect" + "strings" + "unsafe" +) + +type VirDomain struct { + ptr C.virDomainPtr +} + +type VirDomainBlockInfo struct { + ptr C.virDomainBlockInfo +} + +type VirDomainInfo struct { + ptr C.virDomainInfo +} + +type VirTypedParameter struct { + Name string + Value interface{} +} + +type VirDomainMemoryStat struct { + Tag int32 + Val uint64 +} + +type VirVcpuInfo struct { + Number uint32 + State int32 + CpuTime uint64 + Cpu int32 +} + +type VirTypedParameters []VirTypedParameter + +func (dest *VirTypedParameters) loadFromCPtr(params C.virTypedParameterPtr, nParams int) { + // reset slice + *dest = VirTypedParameters{} + + // transform that C array to a go slice + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(params)), + Len: int(nParams), + Cap: int(nParams), + } + rawParams := *(*[]C.struct__virTypedParameter)(unsafe.Pointer(&hdr)) + + // there is probably a more elegant way to deal with that union + for _, rawParam := range rawParams { + name := C.GoStringN(&rawParam.field[0], C.VIR_TYPED_PARAM_FIELD_LENGTH) + if nbIdx := strings.Index(name, "\x00"); nbIdx != -1 { + name = name[:nbIdx] + } + switch rawParam._type { + case C.VIR_TYPED_PARAM_INT: + *dest = append(*dest, VirTypedParameter{name, int(*(*C.int)(unsafe.Pointer(&rawParam.value[0])))}) + case C.VIR_TYPED_PARAM_UINT: + *dest = append(*dest, VirTypedParameter{name, uint32(*(*C.uint)(unsafe.Pointer(&rawParam.value[0])))}) + case C.VIR_TYPED_PARAM_LLONG: + *dest = append(*dest, VirTypedParameter{name, int64(*(*C.longlong)(unsafe.Pointer(&rawParam.value[0])))}) + case C.VIR_TYPED_PARAM_ULLONG: + *dest = append(*dest, VirTypedParameter{name, uint64(*(*C.ulonglong)(unsafe.Pointer(&rawParam.value[0])))}) + case C.VIR_TYPED_PARAM_DOUBLE: + *dest = append(*dest, VirTypedParameter{name, float64(*(*C.double)(unsafe.Pointer(&rawParam.value[0])))}) + case C.VIR_TYPED_PARAM_BOOLEAN: + if int(*(*C.char)(unsafe.Pointer(&rawParam.value[0]))) == 1 { + *dest = append(*dest, VirTypedParameter{name, true}) + } else { + *dest = append(*dest, VirTypedParameter{name, false}) + } + case C.VIR_TYPED_PARAM_STRING: + *dest = append(*dest, VirTypedParameter{name, C.GoString((*C.char)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(&rawParam.value[0])))))}) + } + } +} + +func (d *VirDomain) Free() error { + if result := C.virDomainFree(d.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Create() error { + result := C.virDomainCreate(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) CreateWithFlags(flags uint) error { + result := C.virDomainCreateWithFlags(d.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Destroy() error { + result := C.virDomainDestroy(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Shutdown() error { + result := C.virDomainShutdown(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Reboot(flags uint) error { + result := C.virDomainReboot(d.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) IsActive() (bool, error) { + result := C.virDomainIsActive(d.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (d *VirDomain) IsPersistent() (bool, error) { + result := C.virDomainIsPersistent(d.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (d *VirDomain) SetAutostart(autostart bool) error { + var cAutostart C.int + switch autostart { + case true: + cAutostart = 1 + default: + cAutostart = 0 + } + result := C.virDomainSetAutostart(d.ptr, cAutostart) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) GetAutostart() (bool, error) { + var out C.int + result := C.virDomainGetAutostart(d.ptr, (*C.int)(unsafe.Pointer(&out))) + if result == -1 { + return false, GetLastError() + } + switch out { + case 1: + return true, nil + default: + return false, nil + } +} + +func (d *VirDomain) GetBlockInfo(disk string, flag uint) (VirDomainBlockInfo, error) { + bi := VirDomainBlockInfo{} + var ptr C.virDomainBlockInfo + cDisk := C.CString(disk) + defer C.free(unsafe.Pointer(cDisk)) + result := C.virDomainGetBlockInfo(d.ptr, cDisk, (*C.virDomainBlockInfo)(unsafe.Pointer(&ptr)), C.uint(flag)) + if result == -1 { + return bi, GetLastError() + } + bi.ptr = ptr + return bi, nil +} + +func (b *VirDomainBlockInfo) Allocation() uint64 { + return uint64(b.ptr.allocation) +} + +func (b *VirDomainBlockInfo) Capacity() uint64 { + return uint64(b.ptr.capacity) +} + +func (b *VirDomainBlockInfo) Physical() uint64 { + return uint64(b.ptr.physical) +} + +func (d *VirDomain) GetName() (string, error) { + name := C.virDomainGetName(d.ptr) + if name == nil { + return "", GetLastError() + } + return C.GoString(name), nil +} + +func (d *VirDomain) GetState() ([]int, error) { + var cState C.int + var cReason C.int + result := C.virDomainGetState(d.ptr, + (*C.int)(unsafe.Pointer(&cState)), + (*C.int)(unsafe.Pointer(&cReason)), + 0) + if int(result) == -1 { + return []int{}, GetLastError() + } + return []int{int(cState), int(cReason)}, nil +} + +func (d *VirDomain) GetID() (uint, error) { + id := uint(C.virDomainGetID(d.ptr)) + if id == ^uint(0) { + return id, GetLastError() + } + return id, nil +} + +func (d *VirDomain) GetUUID() ([]byte, error) { + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virDomainGetUUID(d.ptr, (*C.uchar)(cuidPtr)) + if result != 0 { + return []byte{}, GetLastError() + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +func (d *VirDomain) GetUUIDString() (string, error) { + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virDomainGetUUIDString(d.ptr, (*C.char)(cuidPtr)) + if result != 0 { + return "", GetLastError() + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +func (d *VirDomain) GetInfo() (VirDomainInfo, error) { + di := VirDomainInfo{} + var ptr C.virDomainInfo + result := C.virDomainGetInfo(d.ptr, (*C.virDomainInfo)(unsafe.Pointer(&ptr))) + if result == -1 { + return di, GetLastError() + } + di.ptr = ptr + return di, nil +} + +func (d *VirDomain) GetXMLDesc(flags uint32) (string, error) { + result := C.virDomainGetXMLDesc(d.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +func (i *VirDomainInfo) GetState() uint8 { + return uint8(i.ptr.state) +} + +func (i *VirDomainInfo) GetMaxMem() uint64 { + return uint64(i.ptr.maxMem) +} + +func (i *VirDomainInfo) GetMemory() uint64 { + return uint64(i.ptr.memory) +} + +func (i *VirDomainInfo) GetNrVirtCpu() uint16 { + return uint16(i.ptr.nrVirtCpu) +} + +func (i *VirDomainInfo) GetCpuTime() uint64 { + return uint64(i.ptr.cpuTime) +} + +func (d *VirDomain) GetCPUStats(params *VirTypedParameters, nParams int, startCpu int, nCpus uint32, flags uint32) (int, error) { + var cParams C.virTypedParameterPtr + var cParamsLen int + + cParamsLen = int(nCpus) * nParams + + if params != nil && cParamsLen > 0 { + cParams = (C.virTypedParameterPtr)(C.calloc(C.size_t(cParamsLen), C.size_t(unsafe.Sizeof(C.struct__virTypedParameter{})))) + defer C.virTypedParamsFree(cParams, C.int(cParamsLen)) + } else { + cParamsLen = 0 + cParams = nil + } + + result := int(C.virDomainGetCPUStats(d.ptr, (C.virTypedParameterPtr)(cParams), C.uint(nParams), C.int(startCpu), C.uint(nCpus), C.uint(flags))) + if result == -1 { + return result, GetLastError() + } + + if cParamsLen > 0 { + params.loadFromCPtr(cParams, cParamsLen) + } + + return result, nil +} + +// Warning: No test written for this function +func (d *VirDomain) GetInterfaceParameters(device string, params *VirTypedParameters, nParams *int, flags uint32) (int, error) { + var cParams C.virTypedParameterPtr + + if params != nil && *nParams > 0 { + cParams = (C.virTypedParameterPtr)(C.calloc(C.size_t(*nParams), C.size_t(unsafe.Sizeof(C.struct__virTypedParameter{})))) + defer C.virTypedParamsFree(cParams, C.int(*nParams)) + } else { + cParams = nil + } + + result := int(C.virDomainGetInterfaceParameters(d.ptr, C.CString(device), (C.virTypedParameterPtr)(cParams), (*C.int)(unsafe.Pointer(nParams)), C.uint(flags))) + if result == -1 { + return result, GetLastError() + } + + if params != nil && *nParams > 0 { + params.loadFromCPtr(cParams, *nParams) + } + + return result, nil +} + +func (d *VirDomain) GetMetadata(tipus int, uri string, flags uint32) (string, error) { + var cUri *C.char + if uri != "" { + cUri = C.CString(uri) + defer C.free(unsafe.Pointer(cUri)) + } + + result := C.virDomainGetMetadata(d.ptr, C.int(tipus), cUri, C.uint(flags)) + if result == nil { + return "", GetLastError() + + } + defer C.free(unsafe.Pointer(result)) + return C.GoString(result), nil +} + +func (d *VirDomain) SetMetadata(metaDataType int, metaDataCont, uriKey, uri string, flags uint32) error { + var cMetaDataCont *C.char + var cUriKey *C.char + var cUri *C.char + + cMetaDataCont = C.CString(metaDataCont) + defer C.free(unsafe.Pointer(cMetaDataCont)) + + if metaDataType == VIR_DOMAIN_METADATA_ELEMENT { + cUriKey = C.CString(uriKey) + defer C.free(unsafe.Pointer(cUriKey)) + cUri = C.CString(uri) + defer C.free(unsafe.Pointer(cUri)) + } + result := C.virDomainSetMetadata(d.ptr, C.int(metaDataType), cMetaDataCont, cUriKey, cUri, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Undefine() error { + result := C.virDomainUndefine(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetMaxMemory(memory uint) error { + result := C.virDomainSetMaxMemory(d.ptr, C.ulong(memory)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetMemory(memory uint64) error { + result := C.virDomainSetMemory(d.ptr, C.ulong(memory)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetMemoryFlags(memory uint64, flags uint32) error { + result := C.virDomainSetMemoryFlags(d.ptr, C.ulong(memory), C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetMemoryStatsPeriod(period int, flags uint) error { + result := C.virDomainSetMemoryStatsPeriod(d.ptr, C.int(period), C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetVcpus(vcpu uint) error { + result := C.virDomainSetVcpus(d.ptr, C.uint(vcpu)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SetVcpusFlags(vcpu uint, flags uint) error { + result := C.virDomainSetVcpusFlags(d.ptr, C.uint(vcpu), C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Suspend() error { + result := C.virDomainSuspend(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Resume() error { + result := C.virDomainResume(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) AbortJob() error { + result := C.virDomainAbortJob(d.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) DestroyFlags(flags uint) error { + result := C.virDomainDestroyFlags(d.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) ShutdownFlags(flags uint) error { + result := C.virDomainShutdownFlags(d.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) UndefineFlags(flags uint) error { + result := C.virDomainUndefineFlags(d.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) AttachDevice(xml string) error { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainAttachDevice(d.ptr, cXml) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) AttachDeviceFlags(xml string, flags uint) error { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainAttachDeviceFlags(d.ptr, cXml, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) DetachDevice(xml string) error { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainDetachDevice(d.ptr, cXml) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) DetachDeviceFlags(xml string, flags uint) error { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainDetachDeviceFlags(d.ptr, cXml, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) UpdateDeviceFlags(xml string, flags uint) error { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainUpdateDeviceFlags(d.ptr, cXml, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) Screenshot(stream *VirStream, screen, flags uint) (string, error) { + cType := C.virDomainScreenshot(d.ptr, stream.ptr, C.uint(screen), C.uint(flags)) + if cType == nil { + return "", GetLastError() + } + defer C.free(unsafe.Pointer(cType)) + + mimeType := C.GoString(cType) + return mimeType, nil +} + +func (d *VirDomain) SendKey(codeset, holdtime uint, keycodes []uint, flags uint) error { + result := C.virDomainSendKey(d.ptr, C.uint(codeset), C.uint(holdtime), (*C.uint)(unsafe.Pointer(&keycodes[0])), C.int(len(keycodes)), C.uint(flags)) + if result == -1 { + return GetLastError() + } + + return nil +} + +func (d *VirDomain) BlockStatsFlags(disk string, params *VirTypedParameters, nParams int, flags uint32) (int, error) { + var cParams C.virTypedParameterPtr + cDisk := C.CString(disk) + defer C.free(unsafe.Pointer(cDisk)) + + cParamsLen := C.int(nParams) + + if params != nil && nParams > 0 { + cParams = (C.virTypedParameterPtr)(C.calloc(C.size_t(nParams), C.size_t(unsafe.Sizeof(C.struct__virTypedParameter{})))) + defer C.virTypedParamsFree(cParams, cParamsLen) + } else { + cParams = nil + } + + result := int(C.virDomainBlockStatsFlags(d.ptr, cDisk, (C.virTypedParameterPtr)(cParams), &cParamsLen, C.uint(flags))) + if result == -1 { + return result, GetLastError() + } + + if cParamsLen > 0 && params != nil { + params.loadFromCPtr(cParams, nParams) + } + + return int(cParamsLen), nil +} + +type VirDomainBlockStats struct { + RdReq int64 + WrReq int64 + RdBytes int64 + WrBytes int64 +} + +type VirDomainInterfaceStats struct { + RxBytes int64 + RxPackets int64 + RxErrs int64 + RxDrop int64 + TxBytes int64 + TxPackets int64 + TxErrs int64 + TxDrop int64 +} + +func (d *VirDomain) BlockStats(path string) (VirDomainBlockStats, error) { + cPath := C.CString(path) + defer C.free(unsafe.Pointer(cPath)) + + size := C.size_t(unsafe.Sizeof(C.struct__virDomainBlockStats{})) + + cStats := (C.virDomainBlockStatsPtr)(C.malloc(size)) + defer C.free(unsafe.Pointer(cStats)) + + result := C.virDomainBlockStats(d.ptr, cPath, (C.virDomainBlockStatsPtr)(cStats), size) + + if result != 0 { + return VirDomainBlockStats{}, GetLastError() + } + return VirDomainBlockStats{ + WrReq: int64(cStats.wr_req), + RdReq: int64(cStats.rd_req), + RdBytes: int64(cStats.rd_bytes), + WrBytes: int64(cStats.wr_bytes), + }, nil +} + +func (d *VirDomain) InterfaceStats(path string) (VirDomainInterfaceStats, error) { + cPath := C.CString(path) + defer C.free(unsafe.Pointer(cPath)) + + size := C.size_t(unsafe.Sizeof(C.struct__virDomainInterfaceStats{})) + + cStats := (C.virDomainInterfaceStatsPtr)(C.malloc(size)) + defer C.free(unsafe.Pointer(cStats)) + + result := C.virDomainInterfaceStats(d.ptr, cPath, (C.virDomainInterfaceStatsPtr)(cStats), size) + + if result != 0 { + return VirDomainInterfaceStats{}, GetLastError() + } + return VirDomainInterfaceStats{ + RxBytes: int64(cStats.rx_bytes), + RxPackets: int64(cStats.rx_packets), + RxErrs: int64(cStats.rx_errs), + RxDrop: int64(cStats.rx_drop), + TxBytes: int64(cStats.tx_bytes), + TxPackets: int64(cStats.tx_packets), + TxErrs: int64(cStats.tx_errs), + TxDrop: int64(cStats.tx_drop), + }, nil +} + +func (d *VirDomain) MemoryStats(nrStats uint32, flags uint32) ([]VirDomainMemoryStat, error) { + ptr := make([]C.virDomainMemoryStatStruct, nrStats) + + result := C.virDomainMemoryStats( + d.ptr, (C.virDomainMemoryStatPtr)(unsafe.Pointer(&ptr[0])), + C.uint(nrStats), C.uint(flags)) + + if result == -1 { + return []VirDomainMemoryStat{}, GetLastError() + } + + out := make([]VirDomainMemoryStat, result) + for i := 0; i < int(result); i++ { + out = append(out, VirDomainMemoryStat{ + Tag: int32(ptr[i].tag), + Val: uint64(ptr[i].val), + }) + } + return out, nil +} + +func (d *VirDomain) GetVcpus(maxInfo int32) ([]VirVcpuInfo, error) { + ptr := make([]C.virVcpuInfo, maxInfo) + + result := C.virDomainGetVcpus( + d.ptr, (C.virVcpuInfoPtr)(unsafe.Pointer(&ptr[0])), + C.int(maxInfo), nil, C.int(0)) + + if result == -1 { + return []VirVcpuInfo{}, GetLastError() + } + + out := make([]VirVcpuInfo, 0) + for i := 0; i < int(result); i++ { + out = append(out, VirVcpuInfo{ + Number: uint32(ptr[i].number), + State: int32(ptr[i].state), + CpuTime: uint64(ptr[i].cpuTime), + Cpu: int32(ptr[i].cpu), + }) + } + + return out, nil +} + +func (d *VirDomain) GetVcpusFlags(flags uint32) (int32, error) { + result := C.virDomainGetVcpusFlags(d.ptr, C.uint(flags)) + if result == -1 { + return 0, GetLastError() + } + return int32(result), nil +} + +func (d *VirDomain) QemuMonitorCommand(flags uint32, command string) (string, error) { + var cResult *C.char + cCommand := C.CString(command) + defer C.free(unsafe.Pointer(cCommand)) + result := C.virDomainQemuMonitorCommand(d.ptr, cCommand, &cResult, C.uint(flags)) + + if result != 0 { + return "", GetLastError() + } + + rstring := C.GoString(cResult) + C.free(unsafe.Pointer(cResult)) + return rstring, nil +} + +type VirDomainIPAddress struct { + Type int + Addr string + Prefix uint +} + +type VirDomainInterface struct { + Name string + Hwaddr string + Addrs []VirDomainIPAddress +} + +func (d *VirDomain) ListAllInterfaceAddresses(src uint) ([]VirDomainInterface, error) { + var cList *C.virDomainInterfacePtr + numIfaces := int(C.virDomainInterfaceAddresses(d.ptr, (**C.virDomainInterfacePtr)(&cList), C.uint(src), 0)) + if numIfaces == -1 { + return nil, GetLastError() + } + + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numIfaces), + Cap: int(numIfaces), + } + + ifaces := make([]VirDomainInterface, numIfaces) + ifaceSlice := *(*[]C.virDomainInterfacePtr)(unsafe.Pointer(&hdr)) + + for i := 0; i < numIfaces; i++ { + ifaces[i].Name = C.GoString(ifaceSlice[i].name) + ifaces[i].Hwaddr = C.GoString(ifaceSlice[i].hwaddr) + + numAddr := int(ifaceSlice[i].naddrs) + addrHdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(&ifaceSlice[i].addrs)), + Len: int(numAddr), + Cap: int(numAddr), + } + + ifaces[i].Addrs = make([]VirDomainIPAddress, numAddr) + addrSlice := *(*[]C.virDomainIPAddressPtr)(unsafe.Pointer(&addrHdr)) + + for k := 0; k < numAddr; k++ { + ifaces[i].Addrs[k] = VirDomainIPAddress{} + ifaces[i].Addrs[k].Type = int(addrSlice[k]._type) + ifaces[i].Addrs[k].Addr = C.GoString(addrSlice[k].addr) + ifaces[i].Addrs[k].Prefix = uint(addrSlice[k].prefix) + + } + C.virDomainInterfaceFree(ifaceSlice[i]) + } + C.free(unsafe.Pointer(cList)) + return ifaces, nil +} + +func (d *VirDomain) QemuAgentCommand(cmd string, timeout int, flags uint32) string { + cCmd := C.CString(cmd) + defer C.free(unsafe.Pointer(cCmd)) + result := C.virDomainQemuAgentCommand(d.ptr, cCmd, C.int(timeout), C.uint(flags)) + + return C.GoString(result) +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/error.go b/vendor/github.com/dmacvicar/libvirt-go/error.go new file mode 100644 index 00000000..b5285b5c --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/error.go @@ -0,0 +1,504 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> + +#ifndef VIR_FROM_BHYVE +#define VIR_FROM_BHYVE 57 +#endif + +#ifndef VIR_FROM_CRYPTO +#define VIR_FROM_CRYPTO 58 +#endif + +#ifndef VIR_FROM_FIREWALL +#define VIR_FROM_FIREWALL 59 +#endif + +*/ +import "C" + +import "fmt" + +// virErrorLevel +const ( + VIR_ERR_NONE = C.VIR_ERR_NONE + VIR_ERR_WARNING = C.VIR_ERR_WARNING + VIR_ERR_ERROR = C.VIR_ERR_ERROR +) + +// virErrorNumber +const ( + VIR_ERR_OK = C.VIR_ERR_OK + + // internal error + VIR_ERR_INTERNAL_ERROR = C.VIR_ERR_INTERNAL_ERROR + + // memory allocation failure + VIR_ERR_NO_MEMORY = C.VIR_ERR_NO_MEMORY + + // no support for this function + VIR_ERR_NO_SUPPORT = C.VIR_ERR_NO_SUPPORT + + // could not resolve hostname + VIR_ERR_UNKNOWN_HOST = C.VIR_ERR_UNKNOWN_HOST + + // can't connect to hypervisor + VIR_ERR_NO_CONNECT = C.VIR_ERR_NO_CONNECT + + // invalid connection object + VIR_ERR_INVALID_CONN = C.VIR_ERR_INVALID_CONN + + // invalid domain object + VIR_ERR_INVALID_DOMAIN = C.VIR_ERR_INVALID_DOMAIN + + // invalid function argument + VIR_ERR_INVALID_ARG = C.VIR_ERR_INVALID_ARG + + // a command to hypervisor failed + VIR_ERR_OPERATION_FAILED = C.VIR_ERR_OPERATION_FAILED + + // a HTTP GET command to failed + VIR_ERR_GET_FAILED = C.VIR_ERR_GET_FAILED + + // a HTTP POST command to failed + VIR_ERR_POST_FAILED = C.VIR_ERR_POST_FAILED + + // unexpected HTTP error code + VIR_ERR_HTTP_ERROR = C.VIR_ERR_HTTP_ERROR + + // failure to serialize an S-Expr + VIR_ERR_SEXPR_SERIAL = C.VIR_ERR_SEXPR_SERIAL + + // could not open Xen hypervisor control + VIR_ERR_NO_XEN = C.VIR_ERR_NO_XEN + + // failure doing an hypervisor call + VIR_ERR_XEN_CALL = C.VIR_ERR_XEN_CALL + + // unknown OS type + VIR_ERR_OS_TYPE = C.VIR_ERR_OS_TYPE + + // missing kernel information + VIR_ERR_NO_KERNEL = C.VIR_ERR_NO_KERNEL + + // missing root device information + VIR_ERR_NO_ROOT = C.VIR_ERR_NO_ROOT + + // missing source device information + VIR_ERR_NO_SOURCE = C.VIR_ERR_NO_SOURCE + + // missing target device information + VIR_ERR_NO_TARGET = C.VIR_ERR_NO_TARGET + + // missing domain name information + VIR_ERR_NO_NAME = C.VIR_ERR_NO_NAME + + // missing domain OS information + VIR_ERR_NO_OS = C.VIR_ERR_NO_OS + + // missing domain devices information + VIR_ERR_NO_DEVICE = C.VIR_ERR_NO_DEVICE + + // could not open Xen Store control + VIR_ERR_NO_XENSTORE = C.VIR_ERR_NO_XENSTORE + + // too many drivers registered + VIR_ERR_DRIVER_FULL = C.VIR_ERR_DRIVER_FULL + + // not supported by the drivers (DEPRECATED) + VIR_ERR_CALL_FAILED = C.VIR_ERR_CALL_FAILED + + // an XML description is not well formed or broken + VIR_ERR_XML_ERROR = C.VIR_ERR_XML_ERROR + + // the domain already exist + VIR_ERR_DOM_EXIST = C.VIR_ERR_DOM_EXIST + + // operation forbidden on read-only connections + VIR_ERR_OPERATION_DENIED = C.VIR_ERR_OPERATION_DENIED + + // failed to open a conf file + VIR_ERR_OPEN_FAILED = C.VIR_ERR_OPEN_FAILED + + // failed to read a conf file + VIR_ERR_READ_FAILED = C.VIR_ERR_READ_FAILED + + // failed to parse a conf file + VIR_ERR_PARSE_FAILED = C.VIR_ERR_PARSE_FAILED + + // failed to parse the syntax of a conf file + VIR_ERR_CONF_SYNTAX = C.VIR_ERR_CONF_SYNTAX + + // failed to write a conf file + VIR_ERR_WRITE_FAILED = C.VIR_ERR_WRITE_FAILED + + // detail of an XML error + VIR_ERR_XML_DETAIL = C.VIR_ERR_XML_DETAIL + + // invalid network object + VIR_ERR_INVALID_NETWORK = C.VIR_ERR_INVALID_NETWORK + + // the network already exist + VIR_ERR_NETWORK_EXIST = C.VIR_ERR_NETWORK_EXIST + + // general system call failure + VIR_ERR_SYSTEM_ERROR = C.VIR_ERR_SYSTEM_ERROR + + // some sort of RPC error + VIR_ERR_RPC = C.VIR_ERR_RPC + + // error from a GNUTLS call + VIR_ERR_GNUTLS_ERROR = C.VIR_ERR_GNUTLS_ERROR + + // failed to start network + VIR_WAR_NO_NETWORK = C.VIR_WAR_NO_NETWORK + + // domain not found or unexpectedly disappeared + VIR_ERR_NO_DOMAIN = C.VIR_ERR_NO_DOMAIN + + // network not found + VIR_ERR_NO_NETWORK = C.VIR_ERR_NO_NETWORK + + // invalid MAC address + VIR_ERR_INVALID_MAC = C.VIR_ERR_INVALID_MAC + + // authentication failed + VIR_ERR_AUTH_FAILED = C.VIR_ERR_AUTH_FAILED + + // invalid storage pool object + VIR_ERR_INVALID_STORAGE_POOL = C.VIR_ERR_INVALID_STORAGE_POOL + + // invalid storage vol object + VIR_ERR_INVALID_STORAGE_VOL = C.VIR_ERR_INVALID_STORAGE_VOL + + // failed to start storage + VIR_WAR_NO_STORAGE = C.VIR_WAR_NO_STORAGE + + // storage pool not found + VIR_ERR_NO_STORAGE_POOL = C.VIR_ERR_NO_STORAGE_POOL + + // storage volume not found + VIR_ERR_NO_STORAGE_VOL = C.VIR_ERR_NO_STORAGE_VOL + + // failed to start node driver + VIR_WAR_NO_NODE = C.VIR_WAR_NO_NODE + + // invalid node device object + VIR_ERR_INVALID_NODE_DEVICE = C.VIR_ERR_INVALID_NODE_DEVICE + + // node device not found + VIR_ERR_NO_NODE_DEVICE = C.VIR_ERR_NO_NODE_DEVICE + + // security model not found + VIR_ERR_NO_SECURITY_MODEL = C.VIR_ERR_NO_SECURITY_MODEL + + // operation is not applicable at this time + VIR_ERR_OPERATION_INVALID = C.VIR_ERR_OPERATION_INVALID + + // failed to start interface driver + VIR_WAR_NO_INTERFACE = C.VIR_WAR_NO_INTERFACE + + // interface driver not running + VIR_ERR_NO_INTERFACE = C.VIR_ERR_NO_INTERFACE + + // invalid interface object + VIR_ERR_INVALID_INTERFACE = C.VIR_ERR_INVALID_INTERFACE + + // more than one matching interface found + VIR_ERR_MULTIPLE_INTERFACES = C.VIR_ERR_MULTIPLE_INTERFACES + + // failed to start nwfilter driver + VIR_WAR_NO_NWFILTER = C.VIR_WAR_NO_NWFILTER + + // invalid nwfilter object + VIR_ERR_INVALID_NWFILTER = C.VIR_ERR_INVALID_NWFILTER + + // nw filter pool not found + VIR_ERR_NO_NWFILTER = C.VIR_ERR_NO_NWFILTER + + // nw filter pool not found + VIR_ERR_BUILD_FIREWALL = C.VIR_ERR_BUILD_FIREWALL + + // failed to start secret storage + VIR_WAR_NO_SECRET = C.VIR_WAR_NO_SECRET + + // invalid secret + VIR_ERR_INVALID_SECRET = C.VIR_ERR_INVALID_SECRET + + // secret not found + VIR_ERR_NO_SECRET = C.VIR_ERR_NO_SECRET + + // unsupported configuration construct + VIR_ERR_CONFIG_UNSUPPORTED = C.VIR_ERR_CONFIG_UNSUPPORTED + + // timeout occurred during operation + VIR_ERR_OPERATION_TIMEOUT = C.VIR_ERR_OPERATION_TIMEOUT + + // a migration worked, but making the VM persist on the dest host failed + VIR_ERR_MIGRATE_PERSIST_FAILED = C.VIR_ERR_MIGRATE_PERSIST_FAILED + + // a synchronous hook script failed + VIR_ERR_HOOK_SCRIPT_FAILED = C.VIR_ERR_HOOK_SCRIPT_FAILED + + // invalid domain snapshot + VIR_ERR_INVALID_DOMAIN_SNAPSHOT = C.VIR_ERR_INVALID_DOMAIN_SNAPSHOT + + // domain snapshot not found + VIR_ERR_NO_DOMAIN_SNAPSHOT = C.VIR_ERR_NO_DOMAIN_SNAPSHOT + + // stream pointer not valid + VIR_ERR_INVALID_STREAM = C.VIR_ERR_INVALID_STREAM + + // valid API use but unsupported by the given driver + VIR_ERR_ARGUMENT_UNSUPPORTED = C.VIR_ERR_ARGUMENT_UNSUPPORTED + + // storage pool probe failed + VIR_ERR_STORAGE_PROBE_FAILED = C.VIR_ERR_STORAGE_PROBE_FAILED + + // storage pool already built + VIR_ERR_STORAGE_POOL_BUILT = C.VIR_ERR_STORAGE_POOL_BUILT + + // force was not requested for a risky domain snapshot revert + VIR_ERR_SNAPSHOT_REVERT_RISKY = C.VIR_ERR_SNAPSHOT_REVERT_RISKY + + // operation on a domain was canceled/aborted by user + VIR_ERR_OPERATION_ABORTED = C.VIR_ERR_OPERATION_ABORTED + + // authentication cancelled + VIR_ERR_AUTH_CANCELLED = C.VIR_ERR_AUTH_CANCELLED + + // The metadata is not present + VIR_ERR_NO_DOMAIN_METADATA = C.VIR_ERR_NO_DOMAIN_METADATA + + // Migration is not safe + VIR_ERR_MIGRATE_UNSAFE = C.VIR_ERR_MIGRATE_UNSAFE + + // integer overflow + VIR_ERR_OVERFLOW = C.VIR_ERR_OVERFLOW + + // action prevented by block copy job + VIR_ERR_BLOCK_COPY_ACTIVE = C.VIR_ERR_BLOCK_COPY_ACTIVE + + // The requested operation is not supported + VIR_ERR_OPERATION_UNSUPPORTED = C.VIR_ERR_OPERATION_UNSUPPORTED + + // error in ssh transport driver + VIR_ERR_SSH = C.VIR_ERR_SSH + + // guest agent is unresponsive, not running or not usable + VIR_ERR_AGENT_UNRESPONSIVE = C.VIR_ERR_AGENT_UNRESPONSIVE + + // resource is already in use + VIR_ERR_RESOURCE_BUSY = C.VIR_ERR_RESOURCE_BUSY + + // operation on the object/resource was denied + VIR_ERR_ACCESS_DENIED = C.VIR_ERR_ACCESS_DENIED + + // error from a dbus service + VIR_ERR_DBUS_SERVICE = C.VIR_ERR_DBUS_SERVICE + + // the storage vol already exists + VIR_ERR_STORAGE_VOL_EXIST = C.VIR_ERR_STORAGE_VOL_EXIST + + // given CPU is incompatible with host CPU + // added in libvirt 1.2.6 + // VIR_ERR_CPU_INCOMPATIBLE = C.VIR_ERR_CPU_INCOMPATIBLE +) + +// virErrorDomain +const ( + VIR_FROM_NONE = C.VIR_FROM_NONE + + // Error at Xen hypervisor layer + VIR_FROM_XEN = C.VIR_FROM_XEN + + // Error at connection with xend daemon + VIR_FROM_XEND = C.VIR_FROM_XEND + + // Error at connection with xen store + VIR_FROM_XENSTORE = C.VIR_FROM_XENSTORE + + // Error in the S-Expression code + VIR_FROM_SEXPR = C.VIR_FROM_SEXPR + + // Error in the XML code + VIR_FROM_XML = C.VIR_FROM_XML + + // Error when operating on a domain + VIR_FROM_DOM = C.VIR_FROM_DOM + + // Error in the XML-RPC code + VIR_FROM_RPC = C.VIR_FROM_RPC + + // Error in the proxy code; unused since 0.8.6 + VIR_FROM_PROXY = C.VIR_FROM_PROXY + + // Error in the configuration file handling + VIR_FROM_CONF = C.VIR_FROM_CONF + + // Error at the QEMU daemon + VIR_FROM_QEMU = C.VIR_FROM_QEMU + + // Error when operating on a network + VIR_FROM_NET = C.VIR_FROM_NET + + // Error from test driver + VIR_FROM_TEST = C.VIR_FROM_TEST + + // Error from remote driver + VIR_FROM_REMOTE = C.VIR_FROM_REMOTE + + // Error from OpenVZ driver + VIR_FROM_OPENVZ = C.VIR_FROM_OPENVZ + + // Error at Xen XM layer + VIR_FROM_XENXM = C.VIR_FROM_XENXM + + // Error in the Linux Stats code + VIR_FROM_STATS_LINUX = C.VIR_FROM_STATS_LINUX + + // Error from Linux Container driver + VIR_FROM_LXC = C.VIR_FROM_LXC + + // Error from storage driver + VIR_FROM_STORAGE = C.VIR_FROM_STORAGE + + // Error from network config + VIR_FROM_NETWORK = C.VIR_FROM_NETWORK + + // Error from domain config + VIR_FROM_DOMAIN = C.VIR_FROM_DOMAIN + + // Error at the UML driver + VIR_FROM_UML = C.VIR_FROM_UML + + // Error from node device monitor + VIR_FROM_NODEDEV = C.VIR_FROM_NODEDEV + + // Error from xen inotify layer + VIR_FROM_XEN_INOTIFY = C.VIR_FROM_XEN_INOTIFY + + // Error from security framework + VIR_FROM_SECURITY = C.VIR_FROM_SECURITY + + // Error from VirtualBox driver + VIR_FROM_VBOX = C.VIR_FROM_VBOX + + // Error when operating on an interface + VIR_FROM_INTERFACE = C.VIR_FROM_INTERFACE + + // The OpenNebula driver no longer exists. Retained for ABI/API compat only + VIR_FROM_ONE = C.VIR_FROM_ONE + + // Error from ESX driver + VIR_FROM_ESX = C.VIR_FROM_ESX + + // Error from IBM power hypervisor + VIR_FROM_PHYP = C.VIR_FROM_PHYP + + // Error from secret storage + VIR_FROM_SECRET = C.VIR_FROM_SECRET + + // Error from CPU driver + VIR_FROM_CPU = C.VIR_FROM_CPU + + // Error from XenAPI + VIR_FROM_XENAPI = C.VIR_FROM_XENAPI + + // Error from network filter driver + VIR_FROM_NWFILTER = C.VIR_FROM_NWFILTER + + // Error from Synchronous hooks + VIR_FROM_HOOK = C.VIR_FROM_HOOK + + // Error from domain snapshot + VIR_FROM_DOMAIN_SNAPSHOT = C.VIR_FROM_DOMAIN_SNAPSHOT + + // Error from auditing subsystem + VIR_FROM_AUDIT = C.VIR_FROM_AUDIT + + // Error from sysinfo/SMBIOS + VIR_FROM_SYSINFO = C.VIR_FROM_SYSINFO + + // Error from I/O streams + VIR_FROM_STREAMS = C.VIR_FROM_STREAMS + + // Error from VMware driver + VIR_FROM_VMWARE = C.VIR_FROM_VMWARE + + // Error from event loop impl + VIR_FROM_EVENT = C.VIR_FROM_EVENT + + // Error from libxenlight driver + VIR_FROM_LIBXL = C.VIR_FROM_LIBXL + + // Error from lock manager + VIR_FROM_LOCKING = C.VIR_FROM_LOCKING + + // Error from Hyper-V driver + VIR_FROM_HYPERV = C.VIR_FROM_HYPERV + + // Error from capabilities + VIR_FROM_CAPABILITIES = C.VIR_FROM_CAPABILITIES + + // Error from URI handling + VIR_FROM_URI = C.VIR_FROM_URI + + // Error from auth handling + VIR_FROM_AUTH = C.VIR_FROM_AUTH + + // Error from DBus + VIR_FROM_DBUS = C.VIR_FROM_DBUS + + // Error from Parallels + VIR_FROM_PARALLELS = C.VIR_FROM_PARALLELS + + // Error from Device + VIR_FROM_DEVICE = C.VIR_FROM_DEVICE + + // Error from libssh2 connection transport + VIR_FROM_SSH = C.VIR_FROM_SSH + + // Error from lockspace + VIR_FROM_LOCKSPACE = C.VIR_FROM_LOCKSPACE + + // Error from initctl device communication + VIR_FROM_INITCTL = C.VIR_FROM_INITCTL + + // Error from identity code + VIR_FROM_IDENTITY = C.VIR_FROM_IDENTITY + + // Error from cgroups + VIR_FROM_CGROUP = C.VIR_FROM_CGROUP + + // Error from access control manager + VIR_FROM_ACCESS = C.VIR_FROM_ACCESS + + // Error from systemd code + VIR_FROM_SYSTEMD = C.VIR_FROM_SYSTEMD + + // Error from bhyve driver + VIR_FROM_BHYVE = C.VIR_FROM_BHYVE + + // Error from crypto code + VIR_FROM_CRYPTO = C.VIR_FROM_CRYPTO + + // Error from firewall + VIR_FROM_FIREWALL = C.VIR_FROM_FIREWALL +) + +type VirError struct { + Code int + Domain int + Message string + Level int +} + +func (err VirError) Error() string { + return fmt.Sprintf("[Code-%d] [Domain-%d] %s", + err.Code, err.Domain, err.Message) +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/events.go b/vendor/github.com/dmacvicar/libvirt-go/events.go new file mode 100644 index 00000000..6f75eb88 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/events.go @@ -0,0 +1,467 @@ +package libvirt + +import ( + "sync" + "unsafe" +) + +/* + * Golang 1.6 doesn't support C pointers to go memory. + * A hacky-solution might be some multi-threaded approach to support domain events, but let's make it work + * without domain events for now. + */ + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> + +int domainEventLifecycleCallback_cgo(virConnectPtr c, virDomainPtr d, + int event, int detail, void* data); + +int domainEventGenericCallback_cgo(virConnectPtr c, virDomainPtr d, void* data); + +int domainEventRTCChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + long long utcoffset, void* data); + +int domainEventWatchdogCallback_cgo(virConnectPtr c, virDomainPtr d, + int action, void* data); + +int domainEventIOErrorCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *srcPath, const char *devAlias, + int action, void* data); + +int domainEventGraphicsCallback_cgo(virConnectPtr c, virDomainPtr d, + int phase, const virDomainEventGraphicsAddress *local, + const virDomainEventGraphicsAddress *remote, + const char *authScheme, + const virDomainEventGraphicsSubject *subject, void* data); + +int domainEventIOErrorReasonCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *srcPath, const char *devAlias, + int action, const char *reason, void* data); + +int domainEventBlockJobCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *disk, int type, int status, void* data); + +int domainEventDiskChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *oldSrcPath, const char *newSrcPath, + const char *devAlias, int reason, void* data); + +int domainEventTrayChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *devAlias, int reason, void* data); + +int domainEventReasonCallback_cgo(virConnectPtr c, virDomainPtr d, + int reason, void* data); + +int domainEventBalloonChangeCallback_cgo(virConnectPtr c, virDomainPtr d, + unsigned long long actual, void* data); + +int domainEventDeviceRemovedCallback_cgo(virConnectPtr c, virDomainPtr d, + const char *devAlias, void* data); + +int virConnectDomainEventRegisterAny_cgo(virConnectPtr c, virDomainPtr d, + int eventID, virConnectDomainEventGenericCallback cb, + int goCallbackId); +*/ +import "C" + +type DomainLifecycleEvent struct { + Event int + Detail int +} + +type DomainRTCChangeEvent struct { + Utcoffset int64 +} + +type DomainWatchdogEvent struct { + Action int +} + +type DomainIOErrorEvent struct { + SrcPath string + DevAlias string + Action int +} + +type DomainEventGraphicsAddress struct { + Family int + Node string + Service string +} + +type DomainEventGraphicsSubjectIdentity struct { + Type string + Name string +} + +type DomainGraphicsEvent struct { + Phase int + Local DomainEventGraphicsAddress + Remote DomainEventGraphicsAddress + AuthScheme string + Subject []DomainEventGraphicsSubjectIdentity +} + +type DomainIOErrorReasonEvent struct { + DomainIOErrorEvent + Reason string +} + +type DomainBlockJobEvent struct { + Disk string + Type int + Status int +} + +type DomainDiskChangeEvent struct { + OldSrcPath string + NewSrcPath string + DevAlias string + Reason int +} + +type DomainTrayChangeEvent struct { + DevAlias string + Reason int +} + +type DomainReasonEvent struct { + Reason int +} + +type DomainBalloonChangeEvent struct { + Actual uint64 +} + +type DomainDeviceRemovedEvent struct { + DevAlias string +} + +//export domainEventLifecycleCallback +func domainEventLifecycleCallback(c C.virConnectPtr, d C.virDomainPtr, + event int, detail int, + opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainLifecycleEvent{ + Event: event, + Detail: detail, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventGenericCallback +func domainEventGenericCallback(c C.virConnectPtr, d C.virDomainPtr, + opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + return callCallback(opaque, &connection, &domain, nil) +} + +//export domainEventRTCChangeCallback +func domainEventRTCChangeCallback(c C.virConnectPtr, d C.virDomainPtr, + utcoffset int64, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainRTCChangeEvent{ + Utcoffset: utcoffset, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventWatchdogCallback +func domainEventWatchdogCallback(c C.virConnectPtr, d C.virDomainPtr, + action int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainWatchdogEvent{ + Action: action, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventIOErrorCallback +func domainEventIOErrorCallback(c C.virConnectPtr, d C.virDomainPtr, + srcPath string, devAlias string, action int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainIOErrorEvent{ + SrcPath: srcPath, + DevAlias: devAlias, + Action: action, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventGraphicsCallback +func domainEventGraphicsCallback(c C.virConnectPtr, d C.virDomainPtr, + phase int, + local C.virDomainEventGraphicsAddressPtr, + remote C.virDomainEventGraphicsAddressPtr, + authScheme string, + subject C.virDomainEventGraphicsSubjectPtr, + opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + subjectGo := make([]DomainEventGraphicsSubjectIdentity, subject.nidentity) + nidentities := int(subject.nidentity) + identities := (*[1 << 30]C.virDomainEventGraphicsSubjectIdentity)(unsafe.Pointer(&subject.identities))[:nidentities:nidentities] + for _, identity := range identities { + subjectGo = append(subjectGo, + DomainEventGraphicsSubjectIdentity{ + Type: C.GoString(identity._type), + Name: C.GoString(identity.name), + }, + ) + } + + eventDetails := DomainGraphicsEvent{ + Phase: phase, + Local: DomainEventGraphicsAddress{ + Family: int(local.family), + Node: C.GoString(local.node), + Service: C.GoString(local.service), + }, + Remote: DomainEventGraphicsAddress{ + Family: int(remote.family), + Node: C.GoString(remote.node), + Service: C.GoString(remote.service), + }, + AuthScheme: authScheme, + Subject: subjectGo, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventIOErrorReasonCallback +func domainEventIOErrorReasonCallback(c C.virConnectPtr, d C.virDomainPtr, + srcPath string, devAlias string, action int, reason string, + opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainIOErrorReasonEvent{ + DomainIOErrorEvent: DomainIOErrorEvent{ + SrcPath: srcPath, + DevAlias: devAlias, + Action: action, + }, + Reason: reason, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventBlockJobCallback +func domainEventBlockJobCallback(c C.virConnectPtr, d C.virDomainPtr, + disk string, _type int, status int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainBlockJobEvent{ + Disk: disk, + Type: _type, + Status: status, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventDiskChangeCallback +func domainEventDiskChangeCallback(c C.virConnectPtr, d C.virDomainPtr, + oldSrcPath string, newSrcPath string, devAlias string, + reason int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainDiskChangeEvent{ + OldSrcPath: oldSrcPath, + NewSrcPath: newSrcPath, + DevAlias: devAlias, + Reason: reason, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventTrayChangeCallback +func domainEventTrayChangeCallback(c C.virConnectPtr, d C.virDomainPtr, + devAlias string, reason int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainTrayChangeEvent{ + DevAlias: devAlias, + Reason: reason, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventReasonCallback +func domainEventReasonCallback(c C.virConnectPtr, d C.virDomainPtr, + reason int, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainReasonEvent{ + Reason: reason, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventBalloonChangeCallback +func domainEventBalloonChangeCallback(c C.virConnectPtr, d C.virDomainPtr, + actual uint64, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainBalloonChangeEvent{ + Actual: actual, + } + + return callCallback(opaque, &connection, &domain, eventDetails) +} + +//export domainEventDeviceRemovedCallback +func domainEventDeviceRemovedCallback(c C.virConnectPtr, d C.virDomainPtr, + devAlias string, opaque int) int { + + domain := VirDomain{ptr: d} + connection := VirConnection{ptr: c} + + eventDetails := DomainDeviceRemovedEvent{ + DevAlias: devAlias, + } + return callCallback(opaque, &connection, &domain, eventDetails) +} + +type DomainEventCallback func(c *VirConnection, d *VirDomain, + event interface{}, f func()) int + +type domainCallbackContext struct { + cb *DomainEventCallback + f func() +} + +var goCallbackLock sync.RWMutex +var goCallbacks = make(map[int]*domainCallbackContext) +var nextGoCallbackId int + +//export freeCallbackId +func freeCallbackId(goCallbackId int) { + goCallbackLock.Lock() + delete(goCallbacks, goCallbackId) + goCallbackLock.Unlock() +} + +func callCallback(goCallbackId int, c *VirConnection, d *VirDomain, + event interface{}) int { + goCallbackLock.RLock() + ctx := goCallbacks[goCallbackId] + goCallbackLock.RUnlock() + if ctx == nil { + // If this happens there must be a bug in libvirt + panic("Callback arrived after freeCallbackId was called") + } + return (*ctx.cb)(c, d, event, ctx.f) +} + +func (c *VirConnection) DomainEventRegister(dom VirDomain, + eventId int, + callback *DomainEventCallback, + opaque func()) int { + var callbackPtr unsafe.Pointer + context := &domainCallbackContext{ + cb: callback, + f: opaque, + } + goCallbackLock.Lock() + goCallBackId := nextGoCallbackId + nextGoCallbackId++ + goCallbacks[goCallBackId] = context + goCallbackLock.Unlock() + + switch eventId { + case VIR_DOMAIN_EVENT_ID_LIFECYCLE: + callbackPtr = unsafe.Pointer(C.domainEventLifecycleCallback_cgo) + case VIR_DOMAIN_EVENT_ID_REBOOT: + case VIR_DOMAIN_EVENT_ID_CONTROL_ERROR: + callbackPtr = unsafe.Pointer(C.domainEventGenericCallback_cgo) + case VIR_DOMAIN_EVENT_ID_RTC_CHANGE: + callbackPtr = unsafe.Pointer(C.domainEventRTCChangeCallback_cgo) + case VIR_DOMAIN_EVENT_ID_WATCHDOG: + callbackPtr = unsafe.Pointer(C.domainEventWatchdogCallback_cgo) + case VIR_DOMAIN_EVENT_ID_IO_ERROR: + callbackPtr = unsafe.Pointer(C.domainEventIOErrorCallback_cgo) + case VIR_DOMAIN_EVENT_ID_GRAPHICS: + callbackPtr = unsafe.Pointer(C.domainEventGraphicsCallback_cgo) + case VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON: + callbackPtr = unsafe.Pointer(C.domainEventIOErrorReasonCallback_cgo) + case VIR_DOMAIN_EVENT_ID_BLOCK_JOB: + // TODO Post 1.2.4, uncomment later + // case VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2: + callbackPtr = unsafe.Pointer(C.domainEventBlockJobCallback_cgo) + case VIR_DOMAIN_EVENT_ID_DISK_CHANGE: + callbackPtr = unsafe.Pointer(C.domainEventDiskChangeCallback_cgo) + case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: + callbackPtr = unsafe.Pointer(C.domainEventTrayChangeCallback_cgo) + case VIR_DOMAIN_EVENT_ID_PMWAKEUP: + case VIR_DOMAIN_EVENT_ID_PMSUSPEND: + case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK: + callbackPtr = unsafe.Pointer(C.domainEventReasonCallback_cgo) + case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE: + callbackPtr = unsafe.Pointer(C.domainEventBalloonChangeCallback_cgo) + case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED: + callbackPtr = unsafe.Pointer(C.domainEventDeviceRemovedCallback_cgo) + default: + } + ret := C.virConnectDomainEventRegisterAny_cgo(c.ptr, dom.ptr, C.VIR_DOMAIN_EVENT_ID_LIFECYCLE, + C.virConnectDomainEventGenericCallback(callbackPtr), + C.int(goCallBackId)) + if ret == -1 { + goCallbackLock.Lock() + delete(goCallbacks, goCallBackId) + goCallbackLock.Unlock() + return -1 + } + return goCallBackId +} + +func (c *VirConnection) DomainEventDeregister(callbackId int) int { + // Deregister the callback + return int(C.virConnectDomainEventDeregisterAny(c.ptr, C.int(callbackId))) +} + +func EventRegisterDefaultImpl() int { + return int(C.virEventRegisterDefaultImpl()) +} + +func EventRunDefaultImpl() int { + return int(C.virEventRunDefaultImpl()) +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/interface.go b/vendor/github.com/dmacvicar/libvirt-go/interface.go new file mode 100644 index 00000000..60f0c06b --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/interface.go @@ -0,0 +1,87 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirInterface struct { + ptr C.virInterfacePtr +} + +func (n *VirInterface) Create(flags uint32) error { + result := C.virInterfaceCreate(n.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirInterface) Destroy(flags uint32) error { + result := C.virInterfaceDestroy(n.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirInterface) IsActive() (bool, error) { + result := C.virInterfaceIsActive(n.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (n *VirInterface) GetMACString() (string, error) { + result := C.virInterfaceGetMACString(n.ptr) + if result == nil { + return "", GetLastError() + } + mac := C.GoString(result) + return mac, nil +} + +func (n *VirInterface) GetName() (string, error) { + result := C.virInterfaceGetName(n.ptr) + if result == nil { + return "", GetLastError() + } + name := C.GoString(result) + return name, nil +} + +func (n *VirInterface) GetXMLDesc(flags uint32) (string, error) { + result := C.virInterfaceGetXMLDesc(n.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +func (n *VirInterface) Undefine() error { + result := C.virInterfaceUndefine(n.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirInterface) Free() error { + if result := C.virInterfaceFree(n.ptr); result != 0 { + return GetLastError() + } + return nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/libvirt.go b/vendor/github.com/dmacvicar/libvirt-go/libvirt.go new file mode 100644 index 00000000..2248ecd2 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/libvirt.go @@ -0,0 +1,811 @@ +package libvirt + +import ( + "encoding/base64" + "io/ioutil" + "reflect" + "unsafe" +) + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> + +void virErrorFuncDummy(void *userData, virErrorPtr error); + +void virErrorFuncDummy(void *userData, virErrorPtr error) +{ +} + +*/ +import "C" + +func init() { + // libvirt won't print to stderr + C.virSetErrorFunc(nil, C.virErrorFunc(unsafe.Pointer(C.virErrorFuncDummy))) +} + +type VirConnection struct { + ptr C.virConnectPtr +} + +func NewVirConnection(uri string) (VirConnection, error) { + var cUri *C.char + if uri != "" { + cUri = C.CString(uri) + defer C.free(unsafe.Pointer(cUri)) + } + ptr := C.virConnectOpen(cUri) + if ptr == nil { + return VirConnection{}, GetLastError() + } + obj := VirConnection{ptr: ptr} + return obj, nil +} + +func NewVirConnectionReadOnly(uri string) (VirConnection, error) { + var cUri *C.char + if uri != "" { + cUri = C.CString(uri) + defer C.free(unsafe.Pointer(cUri)) + } + ptr := C.virConnectOpenReadOnly(cUri) + if ptr == nil { + return VirConnection{}, GetLastError() + } + obj := VirConnection{ptr: ptr} + return obj, nil +} + +func GetLastError() VirError { + var virErr VirError + err := C.virGetLastError() + + virErr.Code = int(err.code) + virErr.Domain = int(err.domain) + virErr.Message = C.GoString(err.message) + virErr.Level = int(err.level) + + C.virResetError(err) + return virErr +} + +func (c *VirConnection) CloseConnection() (int, error) { + result := int(C.virConnectClose(c.ptr)) + if result == -1 { + return result, GetLastError() + } + return result, nil +} + +func (c *VirConnection) UnrefAndCloseConnection() error { + closeRes := 1 + var err error + for closeRes > 0 { + closeRes, err = c.CloseConnection() + if err != nil { + return err + } + } + return nil +} + +func (c *VirConnection) GetCapabilities() (string, error) { + str := C.virConnectGetCapabilities(c.ptr) + if str == nil { + return "", GetLastError() + } + capabilities := C.GoString(str) + C.free(unsafe.Pointer(str)) + return capabilities, nil +} + +func (c *VirConnection) GetNodeInfo() (VirNodeInfo, error) { + ni := VirNodeInfo{} + var ptr C.virNodeInfo + result := C.virNodeGetInfo(c.ptr, (*C.virNodeInfo)(unsafe.Pointer(&ptr))) + if result == -1 { + return ni, GetLastError() + } + ni.ptr = ptr + return ni, nil +} + +func (c *VirConnection) GetHostname() (string, error) { + str := C.virConnectGetHostname(c.ptr) + if str == nil { + return "", GetLastError() + } + hostname := C.GoString(str) + C.free(unsafe.Pointer(str)) + return hostname, nil +} + +func (c *VirConnection) GetLibVersion() (uint32, error) { + var version C.ulong + if err := C.virConnectGetLibVersion(c.ptr, &version); err < 0 { + return 0, GetLastError() + } + return uint32(version), nil +} + +func (c *VirConnection) GetType() (string, error) { + str := C.virConnectGetType(c.ptr) + if str == nil { + return "", GetLastError() + } + hypDriver := C.GoString(str) + return hypDriver, nil +} + +func (c *VirConnection) IsAlive() (bool, error) { + result := C.virConnectIsAlive(c.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (c *VirConnection) IsEncrypted() (bool, error) { + result := C.virConnectIsEncrypted(c.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (c *VirConnection) IsSecure() (bool, error) { + result := C.virConnectIsSecure(c.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (c *VirConnection) ListDefinedDomains() ([]string, error) { + var names [1024](*C.char) + namesPtr := unsafe.Pointer(&names) + numDomains := C.virConnectListDefinedDomains( + c.ptr, + (**C.char)(namesPtr), + 1024) + if numDomains == -1 { + return nil, GetLastError() + } + goNames := make([]string, numDomains) + for k := 0; k < int(numDomains); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) ListDomains() ([]uint32, error) { + var cDomainsIds [512](uint32) + cDomainsPointer := unsafe.Pointer(&cDomainsIds) + numDomains := C.virConnectListDomains(c.ptr, (*C.int)(cDomainsPointer), 512) + if numDomains == -1 { + return nil, GetLastError() + } + + return cDomainsIds[:numDomains], nil +} + +func (c *VirConnection) ListInterfaces() ([]string, error) { + const maxIfaces = 1024 + var names [maxIfaces](*C.char) + namesPtr := unsafe.Pointer(&names) + numIfaces := C.virConnectListInterfaces( + c.ptr, + (**C.char)(namesPtr), + maxIfaces) + if numIfaces == -1 { + return nil, GetLastError() + } + goNames := make([]string, numIfaces) + for k := 0; k < int(numIfaces); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) ListNetworks() ([]string, error) { + const maxNets = 1024 + var names [maxNets](*C.char) + namesPtr := unsafe.Pointer(&names) + numNetworks := C.virConnectListNetworks( + c.ptr, + (**C.char)(namesPtr), + maxNets) + if numNetworks == -1 { + return nil, GetLastError() + } + goNames := make([]string, numNetworks) + for k := 0; k < int(numNetworks); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) ListStoragePools() ([]string, error) { + const maxPools = 1024 + var names [maxPools](*C.char) + namesPtr := unsafe.Pointer(&names) + numStoragePools := C.virConnectListStoragePools( + c.ptr, + (**C.char)(namesPtr), + maxPools) + if numStoragePools == -1 { + return nil, GetLastError() + } + goNames := make([]string, numStoragePools) + for k := 0; k < int(numStoragePools); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) LookupDomainById(id uint32) (VirDomain, error) { + ptr := C.virDomainLookupByID(c.ptr, C.int(id)) + if ptr == nil { + return VirDomain{}, GetLastError() + } + return VirDomain{ptr: ptr}, nil +} + +func (c *VirConnection) LookupDomainByName(id string) (VirDomain, error) { + cName := C.CString(id) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virDomainLookupByName(c.ptr, cName) + if ptr == nil { + return VirDomain{}, GetLastError() + } + return VirDomain{ptr: ptr}, nil +} + +func (c *VirConnection) LookupByUUIDString(uuid string) (VirDomain, error) { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virDomainLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return VirDomain{}, GetLastError() + } + return VirDomain{ptr: ptr}, nil +} + +func (c *VirConnection) DomainCreateXMLFromFile(xmlFile string, flags uint32) (VirDomain, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirDomain{}, err + } + return c.DomainCreateXML(string(xmlConfig), flags) +} + +func (c *VirConnection) DomainCreateXML(xmlConfig string, flags uint32) (VirDomain, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virDomainCreateXML(c.ptr, cXml, C.uint(flags)) + if ptr == nil { + return VirDomain{}, GetLastError() + } + return VirDomain{ptr: ptr}, nil +} + +func (c *VirConnection) DomainDefineXMLFromFile(xmlFile string) (VirDomain, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirDomain{}, err + } + return c.DomainDefineXML(string(xmlConfig)) +} + +func (c *VirConnection) DomainDefineXML(xmlConfig string) (VirDomain, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virDomainDefineXML(c.ptr, cXml) + if ptr == nil { + return VirDomain{}, GetLastError() + } + return VirDomain{ptr: ptr}, nil +} + +func (c *VirConnection) ListDefinedInterfaces() ([]string, error) { + const maxIfaces = 1024 + var names [maxIfaces](*C.char) + namesPtr := unsafe.Pointer(&names) + numIfaces := C.virConnectListDefinedInterfaces( + c.ptr, + (**C.char)(namesPtr), + maxIfaces) + if numIfaces == -1 { + return nil, GetLastError() + } + goNames := make([]string, numIfaces) + for k := 0; k < int(numIfaces); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) ListDefinedNetworks() ([]string, error) { + const maxNets = 1024 + var names [maxNets](*C.char) + namesPtr := unsafe.Pointer(&names) + numNetworks := C.virConnectListDefinedNetworks( + c.ptr, + (**C.char)(namesPtr), + maxNets) + if numNetworks == -1 { + return nil, GetLastError() + } + goNames := make([]string, numNetworks) + for k := 0; k < int(numNetworks); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) ListDefinedStoragePools() ([]string, error) { + const maxPools = 1024 + var names [maxPools](*C.char) + namesPtr := unsafe.Pointer(&names) + numStoragePools := C.virConnectListDefinedStoragePools( + c.ptr, + (**C.char)(namesPtr), + maxPools) + if numStoragePools == -1 { + return nil, GetLastError() + } + goNames := make([]string, numStoragePools) + for k := 0; k < int(numStoragePools); k++ { + goNames[k] = C.GoString(names[k]) + C.free(unsafe.Pointer(names[k])) + } + return goNames, nil +} + +func (c *VirConnection) NumOfDefinedInterfaces() (int, error) { + result := int(C.virConnectNumOfDefinedInterfaces(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfDefinedNetworks() (int, error) { + result := int(C.virConnectNumOfDefinedNetworks(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfDefinedStoragePools() (int, error) { + result := int(C.virConnectNumOfDefinedStoragePools(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfDomains() (int, error) { + result := int(C.virConnectNumOfDomains(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfInterfaces() (int, error) { + result := int(C.virConnectNumOfInterfaces(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfNetworks() (int, error) { + result := int(C.virConnectNumOfNetworks(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfNWFilters() (int, error) { + result := int(C.virConnectNumOfNWFilters(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NumOfSecrets() (int, error) { + result := int(C.virConnectNumOfSecrets(c.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) NetworkDefineXMLFromFile(xmlFile string) (VirNetwork, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirNetwork{}, err + } + return c.NetworkDefineXML(string(xmlConfig)) +} + +func (c *VirConnection) NetworkDefineXML(xmlConfig string) (VirNetwork, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virNetworkDefineXML(c.ptr, cXml) + if ptr == nil { + return VirNetwork{}, GetLastError() + } + return VirNetwork{ptr: ptr}, nil +} + +func (c *VirConnection) LookupNetworkByName(name string) (VirNetwork, error) { + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virNetworkLookupByName(c.ptr, cName) + if ptr == nil { + return VirNetwork{}, GetLastError() + } + return VirNetwork{ptr: ptr}, nil +} + +func (c *VirConnection) LookupNetworkByUUIDString(uuid string) (VirNetwork, error) { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virNetworkLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return VirNetwork{}, GetLastError() + } + return VirNetwork{ptr: ptr}, nil +} + +func (c *VirConnection) GetSysinfo(flags uint) (string, error) { + cStr := C.virConnectGetSysinfo(c.ptr, C.uint(flags)) + if cStr == nil { + return "", GetLastError() + } + info := C.GoString(cStr) + C.free(unsafe.Pointer(cStr)) + return info, nil +} + +func (c *VirConnection) GetURI() (string, error) { + cStr := C.virConnectGetURI(c.ptr) + if cStr == nil { + return "", GetLastError() + } + uri := C.GoString(cStr) + C.free(unsafe.Pointer(cStr)) + return uri, nil +} + +func (c *VirConnection) GetMaxVcpus(typeAttr string) (int, error) { + var cTypeAttr *C.char + if typeAttr != "" { + cTypeAttr = C.CString(typeAttr) + defer C.free(unsafe.Pointer(cTypeAttr)) + } + result := int(C.virConnectGetMaxVcpus(c.ptr, cTypeAttr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (c *VirConnection) InterfaceDefineXMLFromFile(xmlFile string) (VirInterface, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirInterface{}, err + } + return c.InterfaceDefineXML(string(xmlConfig), 0) +} + +func (c *VirConnection) InterfaceDefineXML(xmlConfig string, flags uint32) (VirInterface, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virInterfaceDefineXML(c.ptr, cXml, C.uint(flags)) + if ptr == nil { + return VirInterface{}, GetLastError() + } + return VirInterface{ptr: ptr}, nil +} + +func (c *VirConnection) LookupInterfaceByName(name string) (VirInterface, error) { + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virInterfaceLookupByName(c.ptr, cName) + if ptr == nil { + return VirInterface{}, GetLastError() + } + return VirInterface{ptr: ptr}, nil +} + +func (c *VirConnection) LookupInterfaceByMACString(mac string) (VirInterface, error) { + cName := C.CString(mac) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virInterfaceLookupByMACString(c.ptr, cName) + if ptr == nil { + return VirInterface{}, GetLastError() + } + return VirInterface{ptr: ptr}, nil +} + +func (c *VirConnection) StoragePoolDefineXMLFromFile(xmlFile string) (VirStoragePool, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirStoragePool{}, err + } + return c.StoragePoolDefineXML(string(xmlConfig), 0) +} + +func (c *VirConnection) StoragePoolDefineXML(xmlConfig string, flags uint32) (VirStoragePool, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virStoragePoolDefineXML(c.ptr, cXml, C.uint(flags)) + if ptr == nil { + return VirStoragePool{}, GetLastError() + } + return VirStoragePool{ptr: ptr}, nil +} + +func (c *VirConnection) LookupStoragePoolByName(name string) (VirStoragePool, error) { + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virStoragePoolLookupByName(c.ptr, cName) + if ptr == nil { + return VirStoragePool{}, GetLastError() + } + return VirStoragePool{ptr: ptr}, nil +} + +func (c *VirConnection) LookupStoragePoolByUUIDString(uuid string) (VirStoragePool, error) { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virStoragePoolLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return VirStoragePool{}, GetLastError() + } + return VirStoragePool{ptr: ptr}, nil +} + +func (c *VirConnection) NWFilterDefineXMLFromFile(xmlFile string) (VirNWFilter, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirNWFilter{}, err + } + return c.NWFilterDefineXML(string(xmlConfig)) +} + +func (c *VirConnection) NWFilterDefineXML(xmlConfig string) (VirNWFilter, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virNWFilterDefineXML(c.ptr, cXml) + if ptr == nil { + return VirNWFilter{}, GetLastError() + } + return VirNWFilter{ptr: ptr}, nil +} + +func (c *VirConnection) LookupNWFilterByName(name string) (VirNWFilter, error) { + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virNWFilterLookupByName(c.ptr, cName) + if ptr == nil { + return VirNWFilter{}, GetLastError() + } + return VirNWFilter{ptr: ptr}, nil +} + +func (c *VirConnection) LookupNWFilterByUUIDString(uuid string) (VirNWFilter, error) { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virNWFilterLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return VirNWFilter{}, GetLastError() + } + return VirNWFilter{ptr: ptr}, nil +} + +func (c *VirConnection) LookupStorageVolByKey(key string) (VirStorageVol, error) { + cKey := C.CString(key) + defer C.free(unsafe.Pointer(cKey)) + ptr := C.virStorageVolLookupByKey(c.ptr, cKey) + if ptr == nil { + return VirStorageVol{}, GetLastError() + } + return VirStorageVol{ptr: ptr}, nil +} + +func (c *VirConnection) LookupStorageVolByPath(path string) (VirStorageVol, error) { + cPath := C.CString(path) + defer C.free(unsafe.Pointer(cPath)) + ptr := C.virStorageVolLookupByPath(c.ptr, cPath) + if ptr == nil { + return VirStorageVol{}, GetLastError() + } + return VirStorageVol{ptr: ptr}, nil +} + +func (c *VirConnection) SecretDefineXMLFromFile(xmlFile string) (VirSecret, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirSecret{}, err + } + return c.SecretDefineXML(string(xmlConfig), 0) +} + +func (c *VirConnection) SecretDefineXML(xmlConfig string, flags uint32) (VirSecret, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virSecretDefineXML(c.ptr, cXml, C.uint(flags)) + if ptr == nil { + return VirSecret{}, GetLastError() + } + return VirSecret{ptr: ptr}, nil +} + +func (c *VirConnection) SecretSetValue(uuid, value string) error { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virSecretLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return GetLastError() + } + + secret, err := base64.StdEncoding.DecodeString(value) + if err != nil { + return err + } + cSecret := C.CString(string(secret)) + defer C.free(unsafe.Pointer(cSecret)) + + res := C.virSecretSetValue(ptr, (*C.uchar)(unsafe.Pointer(cSecret)), C.size_t(len(secret)), 0) + if res != 0 { + return GetLastError() + } + + return nil +} + +func (c *VirConnection) LookupSecretByUUIDString(uuid string) (VirSecret, error) { + cUuid := C.CString(uuid) + defer C.free(unsafe.Pointer(cUuid)) + ptr := C.virSecretLookupByUUIDString(c.ptr, cUuid) + if ptr == nil { + return VirSecret{}, GetLastError() + } + return VirSecret{ptr: ptr}, nil +} + +func (c *VirConnection) LookupSecretByUsage(usageType int, usageID string) (VirSecret, error) { + cUsageID := C.CString(usageID) + defer C.free(unsafe.Pointer(cUsageID)) + ptr := C.virSecretLookupByUsage(c.ptr, C.int(usageType), cUsageID) + if ptr == nil { + return VirSecret{}, GetLastError() + } + return VirSecret{ptr: ptr}, nil +} + +func (c *VirConnection) ListAllInterfaces(flags uint32) ([]VirInterface, error) { + var cList *C.virInterfacePtr + numIfaces := C.virConnectListAllInterfaces(c.ptr, (**C.virInterfacePtr)(&cList), C.uint(flags)) + if numIfaces == -1 { + return nil, GetLastError() + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numIfaces), + Cap: int(numIfaces), + } + var ifaces []VirInterface + slice := *(*[]C.virInterfacePtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + ifaces = append(ifaces, VirInterface{ptr}) + } + C.free(unsafe.Pointer(cList)) + return ifaces, nil +} + +func (c *VirConnection) ListAllNetworks(flags uint32) ([]VirNetwork, error) { + var cList *C.virNetworkPtr + numNets := C.virConnectListAllNetworks(c.ptr, (**C.virNetworkPtr)(&cList), C.uint(flags)) + if numNets == -1 { + return nil, GetLastError() + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numNets), + Cap: int(numNets), + } + var nets []VirNetwork + slice := *(*[]C.virNetworkPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + nets = append(nets, VirNetwork{ptr}) + } + C.free(unsafe.Pointer(cList)) + return nets, nil +} + +func (c *VirConnection) ListAllDomains(flags uint32) ([]VirDomain, error) { + var cList *C.virDomainPtr + numDomains := C.virConnectListAllDomains(c.ptr, (**C.virDomainPtr)(&cList), C.uint(flags)) + if numDomains == -1 { + return nil, GetLastError() + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numDomains), + Cap: int(numDomains), + } + var domains []VirDomain + slice := *(*[]C.virDomainPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + domains = append(domains, VirDomain{ptr}) + } + C.free(unsafe.Pointer(cList)) + return domains, nil +} + +func (c *VirConnection) ListAllNWFilters(flags uint32) ([]VirNWFilter, error) { + var cList *C.virNWFilterPtr + numNWFilters := C.virConnectListAllNWFilters(c.ptr, (**C.virNWFilterPtr)(&cList), C.uint(flags)) + if numNWFilters == -1 { + return nil, GetLastError() + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numNWFilters), + Cap: int(numNWFilters), + } + var filters []VirNWFilter + slice := *(*[]C.virNWFilterPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + filters = append(filters, VirNWFilter{ptr}) + } + C.free(unsafe.Pointer(cList)) + return filters, nil +} + +func (c *VirConnection) ListAllStoragePools(flags uint32) ([]VirStoragePool, error) { + var cList *C.virStoragePoolPtr + numPools := C.virConnectListAllStoragePools(c.ptr, (**C.virStoragePoolPtr)(&cList), C.uint(flags)) + if numPools == -1 { + return nil, GetLastError() + } + hdr := reflect.SliceHeader{ + Data: uintptr(unsafe.Pointer(cList)), + Len: int(numPools), + Cap: int(numPools), + } + var pools []VirStoragePool + slice := *(*[]C.virStoragePoolPtr)(unsafe.Pointer(&hdr)) + for _, ptr := range slice { + pools = append(pools, VirStoragePool{ptr}) + } + C.free(unsafe.Pointer(cList)) + return pools, nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/network.go b/vendor/github.com/dmacvicar/libvirt-go/network.go new file mode 100644 index 00000000..b50d954b --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/network.go @@ -0,0 +1,187 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +const ( + VIR_NETWORK_UPDATE_COMMAND_NONE = C.VIR_NETWORK_UPDATE_COMMAND_NONE + VIR_NETWORK_UPDATE_COMMAND_MODIFY = C.VIR_NETWORK_UPDATE_COMMAND_MODIFY + VIR_NETWORK_UPDATE_COMMAND_DELETE = C.VIR_NETWORK_UPDATE_COMMAND_DELETE + VIR_NETWORK_UPDATE_COMMAND_ADD_LAST = C.VIR_NETWORK_UPDATE_COMMAND_ADD_LAST + VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST = C.VIR_NETWORK_UPDATE_COMMAND_ADD_FIRST +) + +const ( + VIR_NETWORK_UPDATE_AFFECT_CURRENT = C.VIR_NETWORK_UPDATE_AFFECT_CURRENT + VIR_NETWORK_UPDATE_AFFECT_LIVE = C.VIR_NETWORK_UPDATE_AFFECT_LIVE + VIR_NETWORK_UPDATE_AFFECT_CONFIG = C.VIR_NETWORK_UPDATE_AFFECT_CONFIG +) + +const ( + VIR_NETWORK_SECTION_NONE = C.VIR_NETWORK_SECTION_NONE + VIR_NETWORK_SECTION_BRIDGE = C.VIR_NETWORK_SECTION_BRIDGE + VIR_NETWORK_SECTION_DOMAIN = C.VIR_NETWORK_SECTION_DOMAIN + VIR_NETWORK_SECTION_IP = C.VIR_NETWORK_SECTION_IP + VIR_NETWORK_SECTION_IP_DHCP_HOST = C.VIR_NETWORK_SECTION_IP_DHCP_HOST + VIR_NETWORK_SECTION_IP_DHCP_RANGE = C.VIR_NETWORK_SECTION_IP_DHCP_RANGE + VIR_NETWORK_SECTION_FORWARD = C.VIR_NETWORK_SECTION_FORWARD + VIR_NETWORK_SECTION_FORWARD_INTERFACE = C.VIR_NETWORK_SECTION_FORWARD_INTERFACE + VIR_NETWORK_SECTION_FORWARD_PF = C.VIR_NETWORK_SECTION_FORWARD_PF + VIR_NETWORK_SECTION_PORTGROUP = C.VIR_NETWORK_SECTION_PORTGROUP + VIR_NETWORK_SECTION_DNS_HOST = C.VIR_NETWORK_SECTION_DNS_HOST + VIR_NETWORK_SECTION_DNS_TXT = C.VIR_NETWORK_SECTION_DNS_TXT + VIR_NETWORK_SECTION_DNS_SRV = C.VIR_NETWORK_SECTION_DNS_SRV +) + +type VirNetwork struct { + ptr C.virNetworkPtr +} + +func (n *VirNetwork) Free() error { + if result := C.virNetworkFree(n.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (n *VirNetwork) Create() error { + result := C.virNetworkCreate(n.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirNetwork) Destroy() error { + result := C.virNetworkDestroy(n.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirNetwork) IsActive() (bool, error) { + result := C.virNetworkIsActive(n.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (n *VirNetwork) IsPersistent() (bool, error) { + result := C.virNetworkIsPersistent(n.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (n *VirNetwork) GetAutostart() (bool, error) { + var out C.int + result := C.virNetworkGetAutostart(n.ptr, (*C.int)(unsafe.Pointer(&out))) + if result == -1 { + return false, GetLastError() + } + switch out { + case 1: + return true, nil + default: + return false, nil + } +} + +func (n *VirNetwork) SetAutostart(autostart bool) error { + var cAutostart C.int + switch autostart { + case true: + cAutostart = 1 + default: + cAutostart = 0 + } + result := C.virNetworkSetAutostart(n.ptr, cAutostart) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirNetwork) GetName() (string, error) { + name := C.virNetworkGetName(n.ptr) + if name == nil { + return "", GetLastError() + } + return C.GoString(name), nil +} + +func (n *VirNetwork) GetUUID() ([]byte, error) { + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virNetworkGetUUID(n.ptr, (*C.uchar)(cuidPtr)) + if result != 0 { + return []byte{}, GetLastError() + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +func (n *VirNetwork) GetUUIDString() (string, error) { + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virNetworkGetUUIDString(n.ptr, (*C.char)(cuidPtr)) + if result != 0 { + return "", GetLastError() + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +func (n *VirNetwork) GetBridgeName() (string, error) { + result := C.virNetworkGetBridgeName(n.ptr) + if result == nil { + return "", GetLastError() + } + bridge := C.GoString(result) + C.free(unsafe.Pointer(result)) + return bridge, nil +} + +func (n *VirNetwork) GetXMLDesc(flags uint32) (string, error) { + result := C.virNetworkGetXMLDesc(n.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +func (n *VirNetwork) UpdateXMLDesc(xmldesc string, command, section int) error { + xmldescC := C.CString(xmldesc) + result := C.virNetworkUpdate(n.ptr, C.uint(command), C.uint(section), C.int(-1), xmldescC, C.uint(C.VIR_NETWORK_UPDATE_AFFECT_CURRENT)) + C.free(unsafe.Pointer(xmldescC)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (n *VirNetwork) Undefine() error { + result := C.virNetworkUndefine(n.ptr) + if result == -1 { + return GetLastError() + } + return nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/nodeinfo.go b/vendor/github.com/dmacvicar/libvirt-go/nodeinfo.go new file mode 100644 index 00000000..e3fd7e68 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/nodeinfo.go @@ -0,0 +1,50 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirNodeInfo struct { + ptr C.virNodeInfo +} + +func (ni *VirNodeInfo) GetModel() string { + model := C.GoString((*C.char)(unsafe.Pointer(&ni.ptr.model))) + return model +} + +func (ni *VirNodeInfo) GetMemoryKB() uint64 { + return uint64(ni.ptr.memory) +} + +func (ni *VirNodeInfo) GetCPUs() uint32 { + return uint32(ni.ptr.cpus) +} + +func (ni *VirNodeInfo) GetMhz() uint32 { + return uint32(ni.ptr.mhz) +} + +func (ni *VirNodeInfo) GetNodes() uint32 { + return uint32(ni.ptr.nodes) +} + +func (ni *VirNodeInfo) GetSockets() uint32 { + return uint32(ni.ptr.sockets) +} + +func (ni *VirNodeInfo) GetCores() uint32 { + return uint32(ni.ptr.cores) +} + +func (ni *VirNodeInfo) GetThreads() uint32 { + return uint32(ni.ptr.threads) +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/nwfilter.go b/vendor/github.com/dmacvicar/libvirt-go/nwfilter.go new file mode 100644 index 00000000..d196f02f --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/nwfilter.go @@ -0,0 +1,70 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirNWFilter struct { + ptr C.virNWFilterPtr +} + +func (f *VirNWFilter) Free() error { + if result := C.virNWFilterFree(f.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (f *VirNWFilter) GetName() (string, error) { + name := C.virNWFilterGetName(f.ptr) + if name == nil { + return "", GetLastError() + } + return C.GoString(name), nil +} + +func (f *VirNWFilter) Undefine() error { + result := C.virNWFilterUndefine(f.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (f *VirNWFilter) GetUUID() ([]byte, error) { + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virNWFilterGetUUID(f.ptr, (*C.uchar)(cuidPtr)) + if result != 0 { + return []byte{}, GetLastError() + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +func (f *VirNWFilter) GetUUIDString() (string, error) { + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virNWFilterGetUUIDString(f.ptr, (*C.char)(cuidPtr)) + if result != 0 { + return "", GetLastError() + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +func (f *VirNWFilter) GetXMLDesc(flags uint32) (string, error) { + result := C.virNWFilterGetXMLDesc(f.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/secret.go b/vendor/github.com/dmacvicar/libvirt-go/secret.go new file mode 100644 index 00000000..f96360dd --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/secret.go @@ -0,0 +1,78 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirSecret struct { + ptr C.virSecretPtr +} + +func (s *VirSecret) Free() error { + if result := C.virSecretFree(s.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (s *VirSecret) Undefine() error { + result := C.virSecretUndefine(s.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (s *VirSecret) GetUUID() ([]byte, error) { + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virSecretGetUUID(s.ptr, (*C.uchar)(cuidPtr)) + if result != 0 { + return []byte{}, GetLastError() + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +func (s *VirSecret) GetUUIDString() (string, error) { + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virSecretGetUUIDString(s.ptr, (*C.char)(cuidPtr)) + if result != 0 { + return "", GetLastError() + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +func (s *VirSecret) GetUsageID() (string, error) { + result := C.virSecretGetUsageID(s.ptr) + if result == nil { + return "", GetLastError() + } + return C.GoString(result), nil +} + +func (s *VirSecret) GetUsageType() (int, error) { + result := int(C.virSecretGetUsageType(s.ptr)) + if result == -1 { + return 0, GetLastError() + } + return result, nil +} + +func (s *VirSecret) GetXMLDesc(flags uint32) (string, error) { + result := C.virSecretGetXMLDesc(s.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/snapshot.go b/vendor/github.com/dmacvicar/libvirt-go/snapshot.go new file mode 100644 index 00000000..fb91fc51 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/snapshot.go @@ -0,0 +1,95 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirDomainSnapshot struct { + ptr C.virDomainSnapshotPtr +} + +func (s *VirDomainSnapshot) Free() error { + if result := C.virDomainSnapshotFree(s.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (s *VirDomainSnapshot) Delete(flags uint32) error { + result := C.virDomainSnapshotDelete(s.ptr, C.uint(flags)) + if result != 0 { + return GetLastError() + } + return nil +} + +func (s *VirDomainSnapshot) RevertToSnapshot(flags uint32) error { + result := C.virDomainRevertToSnapshot(s.ptr, C.uint(flags)) + if result != 0 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) CreateSnapshotXML(xml string, flags uint32) (VirDomainSnapshot, error) { + cXml := C.CString(xml) + defer C.free(unsafe.Pointer(cXml)) + result := C.virDomainSnapshotCreateXML(d.ptr, cXml, C.uint(flags)) + if result == nil { + return VirDomainSnapshot{}, GetLastError() + } + return VirDomainSnapshot{ptr: result}, nil +} + +func (d *VirDomain) Save(destFile string) error { + cPath := C.CString(destFile) + defer C.free(unsafe.Pointer(cPath)) + result := C.virDomainSave(d.ptr, cPath) + if result == -1 { + return GetLastError() + } + return nil +} + +func (d *VirDomain) SaveFlags(destFile string, destXml string, flags uint32) error { + cDestFile := C.CString(destFile) + cDestXml := C.CString(destXml) + defer C.free(unsafe.Pointer(cDestXml)) + defer C.free(unsafe.Pointer(cDestFile)) + result := C.virDomainSaveFlags(d.ptr, cDestFile, cDestXml, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (conn VirConnection) Restore(srcFile string) error { + cPath := C.CString(srcFile) + defer C.free(unsafe.Pointer(cPath)) + if result := C.virDomainRestore(conn.ptr, cPath); result == -1 { + return GetLastError() + } + return nil +} + +func (conn VirConnection) RestoreFlags(srcFile, xmlConf string, flags uint32) error { + cPath := C.CString(srcFile) + defer C.free(unsafe.Pointer(cPath)) + var cXmlConf *C.char + if xmlConf != "" { + cXmlConf = C.CString(xmlConf) + defer C.free(unsafe.Pointer(cXmlConf)) + } + if result := C.virDomainRestoreFlags(conn.ptr, cPath, cXmlConf, C.uint(flags)); result == -1 { + return GetLastError() + } + return nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/storage_pool.go b/vendor/github.com/dmacvicar/libvirt-go/storage_pool.go new file mode 100644 index 00000000..fc49e4d2 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/storage_pool.go @@ -0,0 +1,210 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "io/ioutil" + "unsafe" +) + +type VirStoragePool struct { + ptr C.virStoragePoolPtr +} + +type VirStoragePoolInfo struct { + ptr C.virStoragePoolInfo +} + +func (p *VirStoragePool) Build(flags uint32) error { + result := C.virStoragePoolBuild(p.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Create(flags uint32) error { + result := C.virStoragePoolCreate(p.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Delete(flags uint32) error { + result := C.virStoragePoolDelete(p.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Destroy() error { + result := C.virStoragePoolDestroy(p.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Free() error { + if result := C.virStoragePoolFree(p.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) GetAutostart() (bool, error) { + var out C.int + result := C.virStoragePoolGetAutostart(p.ptr, (*C.int)(unsafe.Pointer(&out))) + if result == -1 { + return false, GetLastError() + } + switch out { + case 1: + return true, nil + default: + return false, nil + } +} + +func (p *VirStoragePool) GetInfo() (VirStoragePoolInfo, error) { + pi := VirStoragePoolInfo{} + var ptr C.virStoragePoolInfo + result := C.virStoragePoolGetInfo(p.ptr, (*C.virStoragePoolInfo)(unsafe.Pointer(&ptr))) + if result == -1 { + return pi, GetLastError() + } + pi.ptr = ptr + return pi, nil +} + +func (p *VirStoragePool) GetName() (string, error) { + name := C.virStoragePoolGetName(p.ptr) + if name == nil { + return "", GetLastError() + } + return C.GoString(name), nil +} + +func (p *VirStoragePool) GetUUID() ([]byte, error) { + var cUuid [C.VIR_UUID_BUFLEN](byte) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virStoragePoolGetUUID(p.ptr, (*C.uchar)(cuidPtr)) + if result != 0 { + return []byte{}, GetLastError() + } + return C.GoBytes(cuidPtr, C.VIR_UUID_BUFLEN), nil +} + +func (p *VirStoragePool) GetUUIDString() (string, error) { + var cUuid [C.VIR_UUID_STRING_BUFLEN](C.char) + cuidPtr := unsafe.Pointer(&cUuid) + result := C.virStoragePoolGetUUIDString(p.ptr, (*C.char)(cuidPtr)) + if result != 0 { + return "", GetLastError() + } + return C.GoString((*C.char)(cuidPtr)), nil +} + +func (p *VirStoragePool) GetXMLDesc(flags uint32) (string, error) { + result := C.virStoragePoolGetXMLDesc(p.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +func (p *VirStoragePool) IsActive() (bool, error) { + result := C.virStoragePoolIsActive(p.ptr) + if result == -1 { + return false, GetLastError() + } + if result == 1 { + return true, nil + } + return false, nil +} + +func (p *VirStoragePool) SetAutostart(autostart bool) error { + var cAutostart C.int + switch autostart { + case true: + cAutostart = 1 + default: + cAutostart = 0 + } + result := C.virStoragePoolSetAutostart(p.ptr, cAutostart) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Refresh(flags uint32) error { + result := C.virStoragePoolRefresh(p.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (p *VirStoragePool) Undefine() error { + result := C.virStoragePoolUndefine(p.ptr) + if result == -1 { + return GetLastError() + } + return nil +} + +func (i *VirStoragePoolInfo) GetState() uint8 { + return uint8(i.ptr.state) +} + +func (i *VirStoragePoolInfo) GetCapacityInBytes() uint64 { + return uint64(i.ptr.capacity) +} + +func (i *VirStoragePoolInfo) GetAllocationInBytes() uint64 { + return uint64(i.ptr.allocation) +} + +func (i *VirStoragePoolInfo) GetAvailableInBytes() uint64 { + return uint64(i.ptr.available) +} + +func (p *VirStoragePool) StorageVolCreateXMLFromFile(xmlFile string, flags uint32) (VirStorageVol, error) { + xmlConfig, err := ioutil.ReadFile(xmlFile) + if err != nil { + return VirStorageVol{}, err + } + return p.StorageVolCreateXML(string(xmlConfig), flags) +} + +func (p *VirStoragePool) StorageVolCreateXML(xmlConfig string, flags uint32) (VirStorageVol, error) { + cXml := C.CString(string(xmlConfig)) + defer C.free(unsafe.Pointer(cXml)) + ptr := C.virStorageVolCreateXML(p.ptr, cXml, C.uint(flags)) + if ptr == nil { + return VirStorageVol{}, GetLastError() + } + return VirStorageVol{ptr: ptr}, nil +} + +func (p *VirStoragePool) LookupStorageVolByName(name string) (VirStorageVol, error) { + cName := C.CString(name) + defer C.free(unsafe.Pointer(cName)) + ptr := C.virStorageVolLookupByName(p.ptr, cName) + if ptr == nil { + return VirStorageVol{}, GetLastError() + } + return VirStorageVol{ptr: ptr}, nil +} diff --git a/vendor/github.com/dmacvicar/libvirt-go/storage_volume.go b/vendor/github.com/dmacvicar/libvirt-go/storage_volume.go new file mode 100644 index 00000000..c0417675 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/storage_volume.go @@ -0,0 +1,144 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" + +import ( + "unsafe" +) + +type VirStorageVol struct { + ptr C.virStorageVolPtr +} + +type VirStorageVolInfo struct { + ptr C.virStorageVolInfo +} + +func (v *VirStorageVol) Delete(flags uint32) error { + result := C.virStorageVolDelete(v.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) Free() error { + if result := C.virStorageVolFree(v.ptr); result != 0 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) GetInfo() (VirStorageVolInfo, error) { + vi := VirStorageVolInfo{} + var ptr C.virStorageVolInfo + result := C.virStorageVolGetInfo(v.ptr, (*C.virStorageVolInfo)(unsafe.Pointer(&ptr))) + if result == -1 { + return vi, GetLastError() + } + vi.ptr = ptr + return vi, nil +} + +func (i *VirStorageVolInfo) GetType() int { + return int(i.ptr._type) +} + +func (i *VirStorageVolInfo) GetCapacityInBytes() uint64 { + return uint64(i.ptr.capacity) +} + +func (i *VirStorageVolInfo) GetAllocationInBytes() uint64 { + return uint64(i.ptr.allocation) +} + +func (v *VirStorageVol) GetKey() (string, error) { + key := C.virStorageVolGetKey(v.ptr) + if key == nil { + return "", GetLastError() + } + return C.GoString(key), nil +} + +func (v *VirStorageVol) GetName() (string, error) { + name := C.virStorageVolGetName(v.ptr) + if name == nil { + return "", GetLastError() + } + return C.GoString(name), nil +} + +func (v *VirStorageVol) GetPath() (string, error) { + result := C.virStorageVolGetPath(v.ptr) + if result == nil { + return "", GetLastError() + } + path := C.GoString(result) + C.free(unsafe.Pointer(result)) + return path, nil +} + +func (v *VirStorageVol) GetXMLDesc(flags uint32) (string, error) { + result := C.virStorageVolGetXMLDesc(v.ptr, C.uint(flags)) + if result == nil { + return "", GetLastError() + } + xml := C.GoString(result) + C.free(unsafe.Pointer(result)) + return xml, nil +} + +func (v *VirStorageVol) Resize(capacity uint64, flags uint32) error { + result := C.virStorageVolResize(v.ptr, C.ulonglong(capacity), C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) Wipe(flags uint32) error { + result := C.virStorageVolWipe(v.ptr, C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} +func (v *VirStorageVol) WipePattern(algorithm uint32, flags uint32) error { + result := C.virStorageVolWipePattern(v.ptr, C.uint(algorithm), C.uint(flags)) + if result == -1 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) Upload(stream *VirStream, offset, length uint64, flags uint32) error { + if C.virStorageVolUpload(v.ptr, stream.ptr, C.ulonglong(offset), + C.ulonglong(length), C.uint(flags)) == -1 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) Download(stream *VirStream, offset, length uint64, flags uint32) error { + if C.virStorageVolDownload(v.ptr, stream.ptr, C.ulonglong(offset), + C.ulonglong(length), C.uint(flags)) == -1 { + return GetLastError() + } + return nil +} + +func (v *VirStorageVol) LookupPoolByVolume() (VirStoragePool, error) { + poolPtr := C.virStoragePoolLookupByVolume(v.ptr) + if poolPtr == nil { + return VirStoragePool{}, GetLastError() + } + return VirStoragePool{ptr: poolPtr}, nil +} + + diff --git a/vendor/github.com/dmacvicar/libvirt-go/stream.go b/vendor/github.com/dmacvicar/libvirt-go/stream.go new file mode 100644 index 00000000..21b8af10 --- /dev/null +++ b/vendor/github.com/dmacvicar/libvirt-go/stream.go @@ -0,0 +1,79 @@ +package libvirt + +/* +#cgo LDFLAGS: -lvirt +#include <libvirt/libvirt.h> +#include <libvirt/virterror.h> +#include <stdlib.h> +*/ +import "C" +import ( + "io" + "unsafe" +) + +type VirStream struct { + ptr C.virStreamPtr +} + +func NewVirStream(c *VirConnection, flags uint) (*VirStream, error) { + virStream := C.virStreamNew(c.ptr, C.uint(flags)) + if virStream == nil { + return nil, GetLastError() + } + + return &VirStream{ + ptr: virStream, + }, nil +} + +func (v *VirStream) Abort() error { + result := C.virStreamAbort(v.ptr) + if result == -1 { + return GetLastError() + } + + return nil +} + +func (v *VirStream) Close() error { + result := C.virStreamFinish(v.ptr) + if result == -1 { + return GetLastError() + } + + return nil +} + +func (v *VirStream) Free() error { + result := C.virStreamFree(v.ptr) + if result == -1 { + return GetLastError() + } + + return nil +} + +func (v *VirStream) Read(p []byte) (int, error) { + n := C.virStreamRecv(v.ptr, (*C.char)(unsafe.Pointer(&p[0])), C.size_t(len(p))) + if n < 0 { + return 0, GetLastError() + } + if n == 0 { + return 0, io.EOF + } + + return int(n), nil +} + +func (v *VirStream) Write(p []byte) (int, error) { + n := C.virStreamSend(v.ptr, (*C.char)(unsafe.Pointer(&p[0])), C.size_t(len(p))) + if n < 0 { + return 0, GetLastError() + } + if n == 0 { + return 0, io.EOF + } + + return int(n), nil +} |