// ListStoragePools collects the list of storage pools, and allocates an array // to store those objects. // Normally, all storage pools are returned; however, "flags" can be used to // filter the results for a smaller list of targeted pools. The valid flags are // divided into groups, where each group contains bits that describe mutually // exclusive attributes of a pool, and where all bits within a group describe // all possible pools. // The first group of "flags" is PoolListActive (online) and PoolListInactive // (offline) to filter the pools by state. // The second group of "flags" is PoolListPersistent (defined) and // PoolListTransient (running but not defined), to filter the pools by whether // they have persistent config or not. // The third group of "flags" is PoolListAutostart and PoolListNoAutostart, to // filter the pools by whether they are marked as autostart or not. // The last group of "flags" is provided to filter the pools by the types, the // flags include: PoolListDir, PoolListFS, PoolListNetFS, PoolListLogical, // PoolListDisk, PoolListISCSI, PoolListSCSI, PoolListMPath, PoolListRBD, // PoolListSheepdog. func (conn Connection) ListStoragePools(flags StoragePoolListFlag) ([]StoragePool, error) { var cStoragePools []C.virStoragePoolPtr cStoragePoolsSH := (*reflect.SliceHeader)(unsafe.Pointer(&cStoragePools)) conn.log.Printf("reading storage pools (flags = %v)...\n", flags) cRet := C.virConnectListAllStoragePools(conn.virConnect, (**C.virStoragePoolPtr)(unsafe.Pointer(&cStoragePoolsSH.Data)), C.uint(flags)) ret := int32(cRet) if ret == -1 { err := LastError() conn.log.Printf("an error occurred: %v\n", err) return nil, err } defer C.free(unsafe.Pointer(cStoragePoolsSH.Data)) cStoragePoolsSH.Cap = int(ret) cStoragePoolsSH.Len = int(ret) storagePools := make([]StoragePool, ret) for i, cPool := range cStoragePools { storagePools[i] = StoragePool{ log: conn.log, virStoragePool: cPool, } } conn.log.Printf("pools count: %v\n", ret) return storagePools, nil }
func (h *Hypervisor) ListStoragePools(flags uint) ([]*StoragePool, error) { var cpools *C.virStoragePoolPtr result := C.virConnectListAllStoragePools(h.cptr, &cpools, C.uint(flags)) if result == -1 { return nil, GetLastError() } var pools = make([]*StoragePool, result) p := (*[1 << 30]C.virStoragePoolPtr)(unsafe.Pointer(cpools)) for i := 0; i < int(result); i++ { pools[i] = newStoragePool(p[i]) } defer C.free(unsafe.Pointer(cpools)) return pools, 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 }