libvirt_ffi 0.2.1 → 0.5.1

data/lib/libvirt/ffi/storage.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Storage
+      # https://libvirt.org/html/libvirt-libvirt-storage.html
+
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      # enum virStoragePoolState
+      enum :pool_state, [
+          :INACTIVE, 0x0, # Not running
+          :BUILDING, 0x1, # Initializing pool, not available
+          :RUNNING, 0x2, # Running normally
+          :DEGRADED, 0x3, # Running degraded
+          :INACCESSIBLE, 0x4 # Running, but not accessible
+      ]
+
+      # enum virConnectListAllStoragePoolsFlags
+      enum :list_all_pools_flags, [
+          :INACTIVE, 0x1,
+          :ACTIVE, 0x2,
+          :PERSISTENT, 0x4,
+          :TRANSIENT, 0x8,
+          :AUTOSTART, 0x10,
+          :NO_AUTOSTART, 0x20, # List pools by type
+          :DIR, 0x40,
+          :FS, 0x80,
+          :NETFS, 0x100,
+          :LOGICAL, 0x200,
+          :DISK, 0x400,
+          :ISCSI, 0x800,
+          :SCSI, 0x1000,
+          :MPATH, 0x2000,
+          :RBD, 0x4000,
+          :SHEEPDOG, 0x8000,
+          :GLUSTER, 0x10000,
+          :ZFS, 0x20000,
+          :VSTORAGE, 0x40000,
+          :ISCSI_DIRECT, 0x80000
+      ]
+
+      # enum virStorageVolInfoFlags
+      enum :volume_info_flags, [
+          :USE_ALLOCATION, 0x0, # Return the physical size in allocation
+          :GET_PHYSICAL, 0x1
+      ]
+
+      # enum virStorageVolType
+      enum :volume_type, [
+          :FILE, 0x0, # Regular file based volumes
+          :BLOCK, 0x1, # Block based volumes
+          :DIR, 0x2, # Directory-passthrough based volume
+          :NETWORK, 0x3, # Network volumes like RBD (RADOS Block Device)
+          :NETDIR, 0x4, # Network accessible directory that can contain other network volumes
+          :PLOOP, 0x5 # Ploop based volumes
+      ]
+
+      # enum virStorageXMLFlags
+      enum :xml_flags, [
+          :INACTIVE, 0x1 # dump inactive pool/volume information
+      ]
+
+      # struct virStoragePoolInfo {
+      #   int   state #   virStoragePoolState flags
+      #   unsigned long long   capacity #   Logical size bytes
+      #   unsigned long long   allocation #   Current allocation bytes
+      #   unsigned long long   available #   Remaining free space bytes
+      # }
+      class PoolInfoStruct < ::FFI::Struct
+        layout :state, FFI::Storage.enum_type(:pool_state),
+               :capacity, :ulong_long,
+               :allocation, :ulong_long,
+               :available, :ulong_long
+      end
+
+      # struct virStorageVolInfo {
+      #   int   type #   virStorageVolType flags
+      #   unsigned long long   capacity #   Logical size bytes
+      #   unsigned long long   allocation #   Current allocation bytes
+      # }
+      class VolumeInfoStruct < ::FFI::Struct
+        layout :type, FFI::Storage.enum_type(:volume_type),
+               :capacity, :ulong_long,
+               :allocation, :ulong_long
+      end
+
+      # int  virConnectListAllStoragePools (
+      #   virConnectPtr conn,
+      #   virStoragePoolPtr ** pools,
+      #   unsigned int flags
+      # )
+      attach_function :virConnectListAllStoragePools, [:pointer, :pointer, :uint], :int
+
+      # int  virStoragePoolGetInfo  (
+      #   virStoragePoolPtr pool,
+      #   virStoragePoolInfoPtr info
+      # )
+      attach_function :virStoragePoolGetInfo, [:pointer, :pointer], :int
+
+      # char *  virStoragePoolGetXMLDesc  (
+      #   virStoragePoolPtr pool,
+      #   unsigned int flags
+      # )
+      attach_function :virStoragePoolGetXMLDesc, [:pointer, :xml_flags], :string
+
+      # int  virStoragePoolRef  (
+      #   virStoragePoolPtr pool
+      # )
+      attach_function :virStoragePoolRef, [:pointer], :int
+
+      # int  virStoragePoolFree  (
+      #   virStoragePoolPtr pool
+      # )
+      attach_function :virStoragePoolFree, [:pointer], :int
+
+      # int  virStoragePoolListAllVolumes (
+      #   virStoragePoolPtr pool,
+      #   virStorageVolPtr ** vols,
+      #   unsigned int flags
+      # )
+      attach_function :virStoragePoolListAllVolumes, [:pointer, :pointer, :uint], :int
+
+      # int  virStorageVolRef (
+      #   virStorageVolPtr vol
+      # )
+      attach_function :virStorageVolRef, [:pointer], :int
+
+      # int  virStorageVolFree (
+      #   virStorageVolPtr vol
+      # )
+      attach_function :virStorageVolFree, [:pointer], :int
+
+      # int  virStorageVolGetInfo (
+      #   virStorageVolPtr vol,
+      #   virStorageVolInfoPtr info
+      # )
+      attach_function :virStorageVolGetInfo, [:pointer, :pointer], :int
+
+      # char * virStorageVolGetXMLDesc (
+      #   virStorageVolPtr vol,
+      #   unsigned int flags
+      # )
+      attach_function :virStorageVolGetXMLDesc, [:pointer, :xml_flags], :string
+    end
+  end
+end

data/lib/libvirt/ffi/stream.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Stream
+      # https://libvirt.org/html/libvirt-libvirt-stream.html
+
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      # virStreamPtr virStreamNew (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virStreamNew, [:pointer, :uint], :pointer
+
+      # typedef void (*virStreamEventCallback) (
+      #   virStreamPtr stream,
+      #   int events,
+      #   void * opaque
+      # )
+      callback :virStreamEventCallback, [:pointer, :int, :pointer], :void
+
+      # int  virStreamEventAddCallback  (
+      #   virStreamPtr stream,
+      #   int events,
+      #   virStreamEventCallback cb,
+      #   void * opaque,
+      #   virFreeCallback ff
+      # )
+      attach_function :virStreamEventAddCallback, [
+          :pointer,
+          :int,
+          :virStreamEventCallback,
+          :pointer,
+          FFI::Common::FREE_CALLBACK
+      ], :int
+
+      # int  virStreamEventRemoveCallback (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamEventRemoveCallback, [:pointer], :int
+
+      # int  virStreamEventUpdateCallback (
+      #   virStreamPtr stream,
+      #   int events
+      # )
+      attach_function :virStreamEventUpdateCallback, [:pointer, :int], :int
+
+      # int  virStreamFinish  (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamFinish, [:pointer], :int
+
+      # int  virStreamFree  (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamFree, [:pointer], :int
+
+      # int  virStreamAbort (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamAbort, [:pointer], :int
+
+      # int  virStreamRecv (
+      #   virStreamPtr stream,
+      #   char *data,
+      #   size_t nbytes
+      # )
+      attach_function :virStreamRecv, [:pointer, :pointer, :size_t], :int
+    end
+  end
+end

data/lib/libvirt/node_info.rb

@@ -1,46 +1,7 @@
 # frozen_string_literal: true
 
 module Libvirt
-  class NodeInfo
-    def initialize(node_info_ptr)
-      @node_info_ptr = node_info_ptr
-      @node_info_struct = FFI::NodeInfo::Struct.new(node_info_ptr)
-    end
-
-    def [](attr)
-      @node_info_struct[attr]
-    end
-
-    def model
-      @node_info_struct[:model].to_s
-    end
-
-    def cpus
-      @node_info_struct[:cpus]
-    end
-
-    def mhz
-      @node_info_struct[:mhz]
-    end
-
-    def nodes
-      @node_info_struct[:nodes]
-    end
-
-    def sockets
-      @node_info_struct[:sockets]
-    end
-
-    def cores
-      @node_info_struct[:cores]
-    end
-
-    def threads
-      @node_info_struct[:threads]
-    end
-
-    def memory
-      @node_info_struct[:memory]
-    end
+  class NodeInfo < BaseInfo
+    struct_class FFI::Host::NodeInfoStruct
   end
 end

data/lib/libvirt/storage_pool.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class StoragePool
+    def self.load_ref(pointer)
+      result = FFI::Storage.virStoragePoolRef(pointer)
+      raise Errors::LibError, "Couldn't retrieve storage pool reference" if result.negative?
+
+      new(pointer)
+    end
+
+    def initialize(pointer)
+      @ptr = pointer
+
+      free = ->(obj_id) do
+        Util.log(:debug) { "Finalize Libvirt::StoragePool 0x#{obj_id.to_s(16)} @ptr=#{@ptr}," }
+        return unless @ptr
+
+        fr_result = FFI::Storage.virStoragePoolFree(@ptr)
+        warn "Couldn't free Libvirt::StoragePool (0x#{obj_id.to_s(16)}) pointer #{@ptr.address}" if fr_result.negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    def info
+      info_ptr = ::FFI::MemoryPointer.new(FFI::Storage::PoolInfoStruct.by_value)
+      result = FFI::Storage.virStoragePoolGetInfo(@ptr, info_ptr)
+      raise Errors::LibError, "Couldn't get storage pool info" if result.negative?
+
+      StoragePoolInfo.new(info_ptr)
+    end
+
+    def xml_desc(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Storage.enum_type(:xml_flags)
+      result = FFI::Storage.virStoragePoolGetXMLDesc(@ptr, flags)
+      raise Errors::LibError, "Couldn't get storage pool xml desc" if result.nil?
+
+      result
+    end
+
+    def list_all_volumes_qty
+      result = FFI::Storage.virStoragePoolListAllVolumes(@ptr, nil, 0)
+      raise Errors::LibError, "Couldn't retrieve volumes qty" if result.negative?
+
+      result
+    end
+
+    def list_all_volumes
+      size = list_all_volumes_qty
+      return [] if size.zero?
+
+      storage_volumes_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Storage.virStoragePoolListAllVolumes(@ptr, storage_volumes_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve volumes list" if result.negative?
+
+      ptr = storage_volumes_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |stv_ptr| StorageVolume.new(stv_ptr) }
+    end
+
+    private
+
+    def dbg(&block)
+      Util.log(:debug, 'Libvirt::Domain', &block)
+    end
+  end
+end

data/lib/libvirt/storage_pool_info.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class StoragePoolInfo < BaseInfo
+    struct_class FFI::Storage::PoolInfoStruct
+  end
+end

data/lib/libvirt/storage_volume.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class StorageVolume
+    def self.load_ref(pointer)
+      result = FFI::Storage.virStorageVolRef(pointer)
+      raise Errors::LibError, "Couldn't retrieve storage volume reference" if result.negative?
+
+      new(pointer)
+    end
+
+    def initialize(pointer)
+      @ptr = pointer
+
+      free = ->(obj_id) do
+        Util.log(:debug) { "Finalize Libvirt::StorageVolume 0x#{obj_id.to_s(16)} @ptr=#{@ptr}," }
+        return unless @ptr
+
+        fr_result = FFI::Storage.virStorageVolFree(@ptr)
+        warn "Couldn't free Libvirt::StorageVolume (0x#{obj_id.to_s(16)}) pointer #{@ptr.address}" if fr_result.negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    def to_ptr
+      @ptr
+    end
+
+    def info
+      info_ptr = ::FFI::MemoryPointer.new(FFI::Storage::VolumeInfoStruct.by_value)
+      result = FFI::Storage.virStorageVolGetInfo(@ptr, info_ptr)
+      raise Errors::LibError, "Couldn't get storage volume info" if result.negative?
+
+      StorageVolumeInfo.new(info_ptr)
+    end
+
+    def xml_desc(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Storage.enum_type(:xml_flags)
+      result = FFI::Storage.virStorageVolGetXMLDesc(@ptr, flags)
+      raise Errors::LibError, "Couldn't get storage volume xml desc" if result.nil?
+
+      result
+    end
+
+    private
+
+    def dbg(&block)
+      Util.log(:debug, 'Libvirt::Domain', &block)
+    end
+  end
+end

data/lib/libvirt/storage_volume_info.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class StorageVolumeInfo < BaseInfo
+    struct_class FFI::Storage::VolumeInfoStruct
+  end
+end

data/lib/libvirt/stream.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class Stream
+    NONBLOCK = 0x1
+    EVENT_READABLE = 0x1
+    EVENT_WRITABLE = 0x2
+
+    def initialize(stream_ptr)
+      @stream_ptr = stream_ptr
+      @cb = nil
+      @opaque = nil
+
+      free = ->(obj_id) do
+        Util.log(:debug) { "Finalize Libvirt::Stream 0x#{obj_id.to_s(16)} @stream_ptr=#{@stream_ptr}, @cb=#{@cb}, @opaque=#{@opaque}," }
+        return unless @stream_ptr
+
+        if @cb
+          rcb_result = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
+          warn("Couldn't remove callback Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if rcb_result.negative?
+          ab_result = FFI::Stream.virStreamAbort(@stream_ptr)
+          warn("Couldn't abort Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if ab_result.negative?
+        end
+        fr_result = FFI::Stream.virStreamFree(@stream_ptr)
+        warn("Couldn't free Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if fr_result.negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    def to_ptr
+      @stream_ptr
+    end
+
+    # @param events [Integer] bit OR of EVENT_READABLE, EVENT_READABLE
+    # @param opaque [Object]
+    # @yield [Stream]
+    def event_add_callback(events, opaque, &block)
+      dbg { "#event_add_callback events=#{events}, opaque=#{opaque}" }
+
+      raise Errors::LibError, 'callback already added' unless @cb.nil?
+
+      @opaque = opaque
+      @cb = FFI::Stream.callback_function(:virStreamEventCallback) do |_stream_ptr, evs, _op|
+        # stream = Stream.new(stream_ptr)
+        block.call(self, evs, @opaque)
+      end
+
+      result = FFI::Stream.virStreamEventAddCallback(@stream_ptr, events, @cb, nil, nil)
+      raise Errors::LibError, "Couldn't add stream event callback" if result.negative?
+
+      true
+    end
+
+    # @param events [Integer] bit OR of EVENT_READABLE, EVENT_READABLE
+    def event_update_callback(events)
+      dbg { "#event_update_callback events=#{events}" }
+
+      result = FFI::Stream.virStreamEventUpdateCallback(@stream_ptr, events)
+      raise Errors::LibError, "Couldn't remove stream event callback" if result.negative?
+
+      true
+    end
+
+    def event_remove_callback
+      dbg { '#event_remove_callback' }
+
+      result = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
+      raise Errors::LibError, "Couldn't remove stream event callback" if result.negative?
+
+      opaque = @opaque
+      @cb = nil
+      @opaque = nil
+      opaque
+    end
+
+    def finish
+      result = FFI::Stream.virStreamFinish(@stream_ptr)
+      raise Errors::LibError, "Couldn't remove stream event callback" if result.negative?
+
+      @cb = nil
+      @opaque = nil
+    end
+
+    def abort_stream
+      result = FFI::Stream.virStreamAbort(@stream_ptr)
+      raise Errors::LibError, "Couldn't remove stream event callback" if result.negative?
+
+      @cb = nil
+      @opaque = nil
+    end
+
+    def free_stream
+      result = FFI::Stream.virStreamFree(@stream_ptr)
+      raise Errors::LibError, "Couldn't free stream event callback" if result.negative?
+
+      @cb = nil
+      @opaque = nil
+      @stream_ptr = nil
+    end
+
+    def recv(bytes)
+      buffer = ::FFI::MemoryPointer.new(:char, bytes)
+      result = FFI::Stream.virStreamRecv(@stream_ptr, buffer, bytes)
+      if result == -1
+        abort_stream
+        [-1, nil]
+      elsif result.zero?
+        [0, nil]
+      elsif result == -2
+        [-2, nil]
+      elsif result.positive?
+        [result, buffer.read_bytes(result)]
+      else
+        raise Errors::LibError, "Invalid response from virStreamRecv #{result.inspect}"
+      end
+    end
+
+    private
+
+    def dbg(&block)
+      Util.log(:debug, 'Libvirt::Stream', &block)
+    end
+  end
+end