src/dma/vendor/github.com/libvirt/libvirt-go/domain_snapshot.go

   1 /*
   2  * This file is part of the libvirt-go project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  *
  22  * Copyright (c) 2013 Alex Zorin
  23  * Copyright (C) 2016 Red Hat, Inc.
  24  *
  25  */
  26
  27 package libvirt
  28
  29 /*
  30 #cgo pkg-config: libvirt
  31 #include <stdlib.h>
  32 #include "domain_snapshot_wrapper.h"
  33 */
  34 import "C"
  35
  36 import (
  37         "reflect"
  38         "unsafe"
  39 )
  40
  41 type DomainSnapshotCreateFlags int
  42
  43 const (
  44         DOMAIN_SNAPSHOT_CREATE_REDEFINE    = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE)
  45         DOMAIN_SNAPSHOT_CREATE_CURRENT     = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_CURRENT)
  46         DOMAIN_SNAPSHOT_CREATE_NO_METADATA = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_NO_METADATA)
  47         DOMAIN_SNAPSHOT_CREATE_HALT        = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_HALT)
  48         DOMAIN_SNAPSHOT_CREATE_DISK_ONLY   = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_DISK_ONLY)
  49         DOMAIN_SNAPSHOT_CREATE_REUSE_EXT   = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT)
  50         DOMAIN_SNAPSHOT_CREATE_QUIESCE     = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE)
  51         DOMAIN_SNAPSHOT_CREATE_ATOMIC      = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC)
  52         DOMAIN_SNAPSHOT_CREATE_LIVE        = DomainSnapshotCreateFlags(C.VIR_DOMAIN_SNAPSHOT_CREATE_LIVE)
  53 )
  54
  55 type DomainSnapshotListFlags int
  56
  57 const (
  58         DOMAIN_SNAPSHOT_LIST_ROOTS       = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_ROOTS)
  59         DOMAIN_SNAPSHOT_LIST_DESCENDANTS = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_DESCENDANTS)
  60         DOMAIN_SNAPSHOT_LIST_LEAVES      = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_LEAVES)
  61         DOMAIN_SNAPSHOT_LIST_NO_LEAVES   = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_NO_LEAVES)
  62         DOMAIN_SNAPSHOT_LIST_METADATA    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_METADATA)
  63         DOMAIN_SNAPSHOT_LIST_NO_METADATA = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_NO_METADATA)
  64         DOMAIN_SNAPSHOT_LIST_INACTIVE    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_INACTIVE)
  65         DOMAIN_SNAPSHOT_LIST_ACTIVE      = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_ACTIVE)
  66         DOMAIN_SNAPSHOT_LIST_DISK_ONLY   = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_DISK_ONLY)
  67         DOMAIN_SNAPSHOT_LIST_INTERNAL    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_INTERNAL)
  68         DOMAIN_SNAPSHOT_LIST_EXTERNAL    = DomainSnapshotListFlags(C.VIR_DOMAIN_SNAPSHOT_LIST_EXTERNAL)
  69 )
  70
  71 type DomainSnapshotRevertFlags int
  72
  73 const (
  74         DOMAIN_SNAPSHOT_REVERT_RUNNING = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_RUNNING)
  75         DOMAIN_SNAPSHOT_REVERT_PAUSED  = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_PAUSED)
  76         DOMAIN_SNAPSHOT_REVERT_FORCE   = DomainSnapshotRevertFlags(C.VIR_DOMAIN_SNAPSHOT_REVERT_FORCE)
  77 )
  78
  79 type DomainSnapshotDeleteFlags int
  80
  81 const (
  82         DOMAIN_SNAPSHOT_DELETE_CHILDREN      = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN)
  83         DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY)
  84         DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY = DomainSnapshotDeleteFlags(C.VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY)
  85 )
  86
  87 type DomainSnapshot struct {
  88         ptr C.virDomainSnapshotPtr
  89 }
  90
  91 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotFree
  92 func (s *DomainSnapshot) Free() error {
  93         var err C.virError
  94         ret := C.virDomainSnapshotFreeWrapper(s.ptr, &err)
  95         if ret == -1 {
  96                 return makeError(&err)
  97         }
  98         return nil
  99 }
 100
 101 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotRef
 102 func (c *DomainSnapshot) Ref() error {
 103         var err C.virError
 104         ret := C.virDomainSnapshotRefWrapper(c.ptr, &err)
 105         if ret == -1 {
 106                 return makeError(&err)
 107         }
 108         return nil
 109 }
 110
 111 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotDelete
 112 func (s *DomainSnapshot) Delete(flags DomainSnapshotDeleteFlags) error {
 113         var err C.virError
 114         result := C.virDomainSnapshotDeleteWrapper(s.ptr, C.uint(flags), &err)
 115         if result != 0 {
 116                 return makeError(&err)
 117         }
 118         return nil
 119 }
 120
 121 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainRevertToSnapshot
 122 func (s *DomainSnapshot) RevertToSnapshot(flags DomainSnapshotRevertFlags) error {
 123         var err C.virError
 124         result := C.virDomainRevertToSnapshotWrapper(s.ptr, C.uint(flags), &err)
 125         if result != 0 {
 126                 return makeError(&err)
 127         }
 128         return nil
 129 }
 130
 131 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotIsCurrent
 132 func (s *DomainSnapshot) IsCurrent(flags uint32) (bool, error) {
 133         var err C.virError
 134         result := C.virDomainSnapshotIsCurrentWrapper(s.ptr, C.uint(flags), &err)
 135         if result == -1 {
 136                 return false, makeError(&err)
 137         }
 138         if result == 1 {
 139                 return true, nil
 140         }
 141         return false, nil
 142 }
 143
 144 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotHasMetadata
 145 func (s *DomainSnapshot) HasMetadata(flags uint32) (bool, error) {
 146         var err C.virError
 147         result := C.virDomainSnapshotHasMetadataWrapper(s.ptr, C.uint(flags), &err)
 148         if result == -1 {
 149                 return false, makeError(&err)
 150         }
 151         if result == 1 {
 152                 return true, nil
 153         }
 154         return false, nil
 155 }
 156
 157 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetXMLDesc
 158 func (s *DomainSnapshot) GetXMLDesc(flags DomainXMLFlags) (string, error) {
 159         var err C.virError
 160         result := C.virDomainSnapshotGetXMLDescWrapper(s.ptr, C.uint(flags), &err)
 161         if result == nil {
 162                 return "", makeError(&err)
 163         }
 164         xml := C.GoString(result)
 165         C.free(unsafe.Pointer(result))
 166         return xml, nil
 167 }
 168
 169 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetName
 170 func (s *DomainSnapshot) GetName() (string, error) {
 171         var err C.virError
 172         name := C.virDomainSnapshotGetNameWrapper(s.ptr, &err)
 173         if name == nil {
 174                 return "", makeError(&err)
 175         }
 176         return C.GoString(name), nil
 177 }
 178
 179 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotGetParent
 180 func (s *DomainSnapshot) GetParent(flags uint32) (*DomainSnapshot, error) {
 181         var err C.virError
 182         ptr := C.virDomainSnapshotGetParentWrapper(s.ptr, C.uint(flags), &err)
 183         if ptr == nil {
 184                 return nil, makeError(&err)
 185         }
 186         return &DomainSnapshot{ptr: ptr}, nil
 187 }
 188
 189 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotNumChildren
 190 func (s *DomainSnapshot) NumChildren(flags DomainSnapshotListFlags) (int, error) {
 191         var err C.virError
 192         result := int(C.virDomainSnapshotNumChildrenWrapper(s.ptr, C.uint(flags), &err))
 193         if result == -1 {
 194                 return 0, makeError(&err)
 195         }
 196         return result, nil
 197 }
 198
 199 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListChildrenNames
 200 func (s *DomainSnapshot) ListChildrenNames(flags DomainSnapshotListFlags) ([]string, error) {
 201         const maxNames = 1024
 202         var names [maxNames](*C.char)
 203         namesPtr := unsafe.Pointer(&names)
 204         var err C.virError
 205         numNames := C.virDomainSnapshotListChildrenNamesWrapper(
 206                 s.ptr,
 207                 (**C.char)(namesPtr),
 208                 maxNames, C.uint(flags), &err)
 209         if numNames == -1 {
 210                 return nil, makeError(&err)
 211         }
 212         goNames := make([]string, numNames)
 213         for k := 0; k < int(numNames); k++ {
 214                 goNames[k] = C.GoString(names[k])
 215                 C.free(unsafe.Pointer(names[k]))
 216         }
 217         return goNames, nil
 218 }
 219
 220 // See also https://libvirt.org/html/libvirt-libvirt-domain-snapshot.html#virDomainSnapshotListAllChildren
 221 func (d *DomainSnapshot) ListAllChildren(flags DomainSnapshotListFlags) ([]DomainSnapshot, error) {
 222         var cList *C.virDomainSnapshotPtr
 223         var err C.virError
 224         numVols := C.virDomainSnapshotListAllChildrenWrapper(d.ptr, (**C.virDomainSnapshotPtr)(&cList), C.uint(flags), &err)
 225         if numVols == -1 {
 226                 return nil, makeError(&err)
 227         }
 228         hdr := reflect.SliceHeader{
 229                 Data: uintptr(unsafe.Pointer(cList)),
 230                 Len:  int(numVols),
 231                 Cap:  int(numVols),
 232         }
 233         var pools []DomainSnapshot
 234         slice := *(*[]C.virDomainSnapshotPtr)(unsafe.Pointer(&hdr))
 235         for _, ptr := range slice {
 236                 pools = append(pools, DomainSnapshot{ptr})
 237         }
 238         C.free(unsafe.Pointer(cList))
 239         return pools, nil
 240 }