libvirt_ffi 0.5.6 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc49a5a9986110313860c3dd0390c7485e598b4407a52d35009381c1255ca9c5
-  data.tar.gz: 6ebd4be029bba4e8a50dc0efc996d91e357e8d7616b1f64f66dde66503dcfc21
+  metadata.gz: 5f84407d986359b92b8ad0eaf854f85d098e93835d218a69a9a346f864176c9d
+  data.tar.gz: c339098e1c00e91f229f814eb399e1ba1980673428d1bf78c565a79080d5456e
 SHA512:
-  metadata.gz: 0d9716eca3d06aa6d0e3479e50c1bb93142968a9b34ad3df59a35a53dfab5b651f59d49e096a89362275700b2cdfd72f6b9832c6bbd187645fb3d236e6478afe
-  data.tar.gz: cac12813a17c8ef4a6bd41ebbed45437d3c3908254866435bcb3bdeb17b457e65c6107c72b4fdd9b553699af2ee8608d2a6a56b6d4bc10ac0437d932e1acd15d
+  metadata.gz: ef9bf3632b42bc37324dbd9cc382b908f6320cdb7a8c16c91bd05a2b5c4f402d2fb675079c3ab0fce9157ad4557caa4b5bd37044841b1ce558c7d2eaf9901502
+  data.tar.gz: 504c1ac8e2c3df785f8754e2abc3bc5643dc7c5c553a8f10793f9e14ea40da9c07961fb510b6a4ae701f2d9df66f689acec0cf09d593a7d23d663e52703b5309

data/lib/libvirt.rb

@@ -2,7 +2,7 @@
 
 require 'ffi'
 require 'objspace'
-require 'libvirt/domain_callback_storage'
+require 'libvirt/host_callback_storage'
 require 'libvirt/util'
 require 'libvirt/errors'
 require 'libvirt/ffi'
@@ -16,6 +16,8 @@ require 'libvirt/domain'
 require 'libvirt/stream'
 require 'libvirt/storage_pool'
 require 'libvirt/storage_volume'
+require 'libvirt/network'
+require 'libvirt/interface'
 require 'libvirt/version'
 
 module Libvirt

data/lib/libvirt/base_info.rb

@@ -16,6 +16,7 @@ module Libvirt
       end
     end
 
+    # @param pointer [FFI::Pointer]
     def initialize(pointer)
       raise ArgumentError, "Can't initialize base class #{self.class}" if self.class == BaseInfo
 
@@ -23,12 +24,19 @@ module Libvirt
       @struct = self.class._struct_class.new(pointer)
     end
 
+    # @param attr [Symbol]
+    # @return [Object, nil]
     def [](attr)
       @struct[attr]
     end
 
+    # @return [Hash]
     def to_h
       @struct.members.map { |attr| [attr, @struct[attr]] }.to_h
     end
+
+    def to_ptr
+      @struct.to_ptr
+    end
   end
 end

data/lib/libvirt/connection.rb

@@ -3,19 +3,60 @@
 module Libvirt
   class Connection
     DOMAIN_EVENT_IDS = FFI::Domain.enum_type(:event_id).symbols.dup.freeze
+    POOL_EVENT_IDS = FFI::Storage.enum_type(:event_id).symbols.dup.freeze
+    NETWORK_EVENT_IDS = FFI::Network.enum_type(:event_id).symbols.dup.freeze
 
-    STORAGE = DomainCallbackStorage.new
+    DOMAIN_STORAGE = HostCallbackStorage.new(:domain_event)
+    POOL_STORAGE = HostCallbackStorage.new(:storage_pool_event)
+    NETWORK_STORAGE = HostCallbackStorage.new(:network_event)
+    CLOSE_STORAGE = HostCallbackStorage.new(:close)
 
     DOMAIN_EVENT_CALLBACKS = DOMAIN_EVENT_IDS.map do |event_id_sym|
       func = FFI::Domain.event_callback_for(event_id_sym) do |conn_ptr, dom_ptr, *args, op_ptr|
+        Util.log(:debug, "DOMAIN_EVENT_CALLBACKS[#{event_id_sym}]") do
+          "inside callback conn_ptr=#{conn_ptr}, pool_ptr=#{dom_ptr}, args=#{args}, op_ptr=#{op_ptr}"
+        end
         connection = Connection.load_ref(conn_ptr)
         domain = Domain.load_ref(dom_ptr)
-        block, opaque = STORAGE.retrieve_from_pointer(op_ptr)
+        block, opaque = DOMAIN_STORAGE.retrieve_from_pointer(op_ptr)
         block.call(connection, domain, *args, opaque)
       end
       [event_id_sym, func]
     end.to_h.freeze
 
+    POOL_EVENT_CALLBACKS = POOL_EVENT_IDS.map do |event_id_sym|
+      func = FFI::Storage.event_callback_for(event_id_sym) do |conn_ptr, pool_ptr, *args, op_ptr|
+        Util.log(:debug, "POOL_EVENT_CALLBACKS[#{event_id_sym}]") do
+          "inside callback conn_ptr=#{conn_ptr}, pool_ptr=#{pool_ptr}, args=#{args}, op_ptr=#{op_ptr}"
+        end
+        connection = Connection.load_ref(conn_ptr)
+        pool = StoragePool.load_ref(pool_ptr)
+        block, opaque = POOL_STORAGE.retrieve_from_pointer(op_ptr)
+        block.call(connection, pool, *args, opaque)
+      end
+      [event_id_sym, func]
+    end.to_h.freeze
+
+    NETWORK_EVENT_CALLBACKS = NETWORK_EVENT_IDS.map do |event_id_sym|
+      func = FFI::Network.event_callback_for(event_id_sym) do |conn_ptr, pool_ptr, *args, op_ptr|
+        Util.log(:debug, "NETWORK_EVENT_CALLBACKS[#{event_id_sym}]") do
+          "inside callback conn_ptr=#{conn_ptr}, pool_ptr=#{pool_ptr}, args=#{args}, op_ptr=#{op_ptr}"
+        end
+        connection = Connection.load_ref(conn_ptr)
+        pool = Network.load_ref(pool_ptr)
+        block, opaque = NETWORK_STORAGE.retrieve_from_pointer(op_ptr)
+        block.call(connection, pool, *args, opaque)
+      end
+      [event_id_sym, func]
+    end.to_h.freeze
+
+    CLOSE_CALLBACK = FFI::Host.callback_function(:virConnectCloseFunc) do |conn_ptr, reason, op_ptr|
+      Util.log(:debug, 'CLOSE_CALLBACK') { "inside callback conn_ptr=#{conn_ptr}, reason=#{reason}, op_ptr=#{op_ptr}" }
+      connection = Connection.load_ref(conn_ptr)
+      block, opaque = CLOSE_STORAGE.retrieve_from_pointer(op_ptr)
+      block.call(connection, reason, opaque)
+    end
+
     def self.load_ref(conn_ptr)
       ref_result = FFI::Host.virConnectRef(conn_ptr)
       raise Errors::LibError, "Couldn't retrieve connection reference" if ref_result.negative?
@@ -134,25 +175,95 @@ module Libvirt
       ptr.get_array_of_pointer(0, size).map { |stp_ptr| StoragePool.new(stp_ptr) }
     end
 
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Integer]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_networks_qty(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Network.enum_type(:list_all_flags)
+      result = FFI::Network.virConnectListAllNetworks(@conn_ptr, nil, flags)
+      raise Errors::LibError, "Couldn't retrieve networks qty with flags #{flags.to_s(16)}" if result.negative?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Array<Libvirt::Network>, Array]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_networks(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Network.enum_type(:list_all_flags)
+      size = list_all_networks_qty(flags)
+      return [] if size.zero?
+
+      networks_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Network.virConnectListAllNetworks(@conn_ptr, networks_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve networks list" if result.negative?
+
+      ptr = networks_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |n_ptr| Network.new(n_ptr) }
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Integer]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_interfaces_qty(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Interface.enum_type(:list_all_flags)
+      result = FFI::Interface.virConnectListAllInterfaces(@conn_ptr, nil, flags)
+      raise Errors::LibError, "Couldn't retrieve interfaces qty with flags #{flags.to_s(16)}" if result.negative?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Array<Libvirt::Interface>, Array]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_interfaces(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Interface.enum_type(:list_all_flags)
+      size = list_all_interfaces_qty(flags)
+      return [] if size.zero?
+
+      interfaces_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Interface.virConnectListAllInterfaces(@conn_ptr, interfaces_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve interfaces list" if result.negative?
+
+      ptr = interfaces_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |i_ptr| Interface.new(i_ptr) }
+    end
+
     def register_close_callback(opaque = nil, &block)
       dbg { "#register_close_callback opaque=#{opaque}" }
-      raise ArgumentError, 'close function already registered' if @close_data
-
-      @close_data = { opaque: opaque, block: block }
-      @close_cb = FFI::Host.callback_function(:virConnectCloseFunc) do |_conn, reason, _op|
-        dbg { "CONNECTION CLOSED @conn_ptr=#{@conn_ptr} reason=#{reason}" }
-        block = @close_data[:block]
-        opaque = @close_data[:opaque]
-        # we clear @closed_data here, because connection can be opened again and
-        # add new close callback inside `block`.
-        @close_data = nil
-        block.call(self, reason, opaque)
-      end
-      @close_free_func = FFI::Common.free_function do
-        dbg { "CONNECTION CLOSED FREE FUNC @conn_ptr=#{@conn_ptr}" }
-        @close_cb = @close_free_func = @close_data = nil
+
+      cb_data, cb_data_free_func = CLOSE_STORAGE.allocate_struct
+      result = FFI::Host.virConnectRegisterCloseCallback(
+          @conn_ptr,
+          CLOSE_CALLBACK,
+          cb_data.pointer,
+          cb_data_free_func
+      )
+      if result.negative?
+        cb_data.pointer.free
+        raise Errors::LibError, "Couldn't register connection close callback"
       end
-      FFI::Host.virConnectRegisterCloseCallback(@conn_ptr, @close_cb, nil, @close_free_func)
+
+      CLOSE_STORAGE.store_struct(
+          cb_data,
+          connection_pointer: @conn_ptr,
+          callback_id: result,
+          cb: block,
+          opaque: opaque,
+          free_func: cb_data_free_func
+      )
+      result
+    end
+
+    def deregister_close_callback
+      dbg { '#deregister_close_callback' }
+
+      result = FFI::Host.virConnectUnregisterCloseCallback(@conn_ptr, CLOSE_CALLBACK)
+      raise Errors::LibError, "Couldn't deregister close callback" if result.negative?
+
+      # virConnectUnregisterCloseCallback will call free func
+      # So we don't need to remove object from CLOSE_STORAGE here.
+      true
     end
 
     # @yield conn, dom, *args
@@ -163,7 +274,7 @@ module Libvirt
       event_id, event_id_sym = Util.parse_enum(enum, event_id)
       cb = DOMAIN_EVENT_CALLBACKS.fetch(event_id_sym)
 
-      cb_data, cb_data_free_func = STORAGE.allocate_struct
+      cb_data, cb_data_free_func = DOMAIN_STORAGE.allocate_struct
 
       result = FFI::Domain.virConnectDomainEventRegisterAny(
           @conn_ptr,
@@ -178,12 +289,13 @@ module Libvirt
         raise Errors::LibError, "Couldn't register domain event callback"
       end
 
-      STORAGE.store_struct(
+      DOMAIN_STORAGE.store_struct(
           cb_data,
           connection_pointer: @conn_ptr,
           callback_id: result,
           cb: block,
-          opaque: opaque
+          opaque: opaque,
+          free_func: cb_data_free_func
       )
       result
     end
@@ -195,7 +307,95 @@ module Libvirt
       raise Errors::LibError, "Couldn't deregister domain event callback" if result.negative?
 
       # virConnectDomainEventDeregisterAny will call free func
-      # So we don't need to remove object from STORAGE here.
+      # So we don't need to remove object from DOMAIN_STORAGE here.
+      true
+    end
+
+    def register_storage_pool_event_callback(event_id, storage_pool = nil, opaque = nil, &block)
+      dbg { "#register_storage_pool_event_callback event_id=#{event_id}" }
+
+      enum = FFI::Storage.enum_type(:event_id)
+      event_id, event_id_sym = Util.parse_enum(enum, event_id)
+      cb = POOL_EVENT_CALLBACKS.fetch(event_id_sym)
+
+      cb_data, cb_data_free_func = POOL_STORAGE.allocate_struct
+
+      result = FFI::Storage.virConnectStoragePoolEventRegisterAny(
+          @conn_ptr,
+          storage_pool&.to_ptr,
+          event_id,
+          cb,
+          cb_data.pointer,
+          cb_data_free_func
+      )
+      if result.negative?
+        cb_data.pointer.free
+        raise Errors::LibError, "Couldn't register storage pool event callback"
+      end
+
+      POOL_STORAGE.store_struct(
+          cb_data,
+          connection_pointer: @conn_ptr,
+          callback_id: result,
+          cb: block,
+          opaque: opaque,
+          free_func: cb_data_free_func
+      )
+      result
+    end
+
+    def deregister_storage_pool_event_callback(callback_id)
+      dbg { "#deregister_storage_pool_event_callback callback_id=#{callback_id}" }
+
+      result = FFI::Storage.virConnectStoragePoolEventDeregisterAny(@conn_ptr, callback_id)
+      raise Errors::LibError, "Couldn't deregister storage pool event callback" if result.negative?
+
+      # virConnectStoragePoolEventDeregisterAny will call free func
+      # So we don't need to remove object from POOL_STORAGE here.
+      true
+    end
+
+    def register_network_event_callback(event_id, network = nil, opaque = nil, &block)
+      dbg { "#register_network_event_callback event_id=#{event_id}" }
+
+      enum = FFI::Network.enum_type(:event_id)
+      event_id, event_id_sym = Util.parse_enum(enum, event_id)
+      cb = NETWORK_EVENT_CALLBACKS.fetch(event_id_sym)
+
+      cb_data, cb_data_free_func = NETWORK_STORAGE.allocate_struct
+
+      result = FFI::Network.virConnectNetworkEventRegisterAny(
+          @conn_ptr,
+          network&.to_ptr,
+          event_id,
+          cb,
+          cb_data.pointer,
+          cb_data_free_func
+      )
+      if result.negative?
+        cb_data.pointer.free
+        raise Errors::LibError, "Couldn't register network event callback"
+      end
+
+      NETWORK_STORAGE.store_struct(
+          cb_data,
+          connection_pointer: @conn_ptr,
+          callback_id: result,
+          cb: block,
+          opaque: opaque,
+          free_func: cb_data_free_func
+      )
+      result
+    end
+
+    def deregister_network_event_callback(callback_id)
+      dbg { "#deregister_network_event_callback callback_id=#{callback_id}" }
+
+      result = FFI::Network.virConnectNetworkEventDeregisterAny(@conn_ptr, callback_id)
+      raise Errors::LibError, "Couldn't deregister network event callback" if result.negative?
+
+      # virConnectNetworkEventDeregisterAny will call free func
+      # So we don't need to remove object from NETWORK_STORAGE here.
       true
     end
 
@@ -244,6 +444,51 @@ module Libvirt
       Domain.new(pointer)
     end
 
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def create_network(xml)
+      pointer = FFI::Network.virNetworkCreateXML(@ptr, xml)
+      raise Errors::LibError, "Couldn't create network with xml" if pointer.null?
+
+      Network.new(pointer)
+    end
+
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def define_network(xml)
+      pointer = FFI::Network.virNetworkDefineXML(@ptr, xml)
+      raise Errors::LibError, "Couldn't define network with xml" if pointer.null?
+
+      Network.new(pointer)
+    end
+
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def define_interface(xml)
+      pointer = FFI::Interface.virInterfaceDefineXML(@conn_ptr, xml, 0)
+      raise Errors::LibError, "Couldn't define interface with xml" if pointer.null?
+
+      Interface.new(pointer)
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def begin_interface_change
+      result = FFI::Interface.virInterfaceChangeBegin(@conn_ptr, 0)
+      raise Errors::LibError, "Couldn't begin interface change" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def commit_interface_change
+      result = FFI::Interface.virInterfaceChangeCommit(@conn_ptr, 0)
+      raise Errors::LibError, "Couldn't commit interface change" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def rollback_interface_change
+      result = FFI::Interface.virInterfaceChangeRollback(@conn_ptr, 0)
+      raise Errors::LibError, "Couldn't rollback interface change" if result.negative?
+    end
+
     private
 
     def set_connection(conn_ptr)

data/lib/libvirt/domain.rb

@@ -38,7 +38,7 @@ module Libvirt
     end
 
     def uuid
-      buff = ::FFI::MemoryPointer.new(:char, FFI::Domain::UUID_STRING_BUFLEN)
+      buff = ::FFI::MemoryPointer.new(:char, Util::UUID_STRING_BUFLEN)
       result = FFI::Domain.virDomainGetUUIDString(@dom_ptr, buff)
       raise Errors::LibError, "Couldn't get domain uuid" if result.negative?
 
@@ -46,13 +46,34 @@ module Libvirt
     end
 
     def name
-      FFI::Domain.virDomainGetName(@dom_ptr)
+      result = FFI::Domain.virDomainGetName(@dom_ptr)
+      raise Errors::LibError, "Couldn't retrieve storage pool name" if result.nil?
+
+      result
     end
 
     def max_vcpus
       FFI::Domain.virDomainGetMaxVcpus(@dom_ptr)
     end
 
+    # @return [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def auto_start
+      value = ::FFI::MemoryPointer.new(:int)
+      result = FFI::Domain.virDomainGetAutostart(@dom_ptr, value)
+      raise Errors::LibError, "Couldn't get domain auto_start" if result.negative?
+
+      value.read_int == 1
+    end
+
+    # @param value [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def set_auto_start(value)
+      value = value ? 1 : 0
+      result = FFI::Domain.virDomainSetAutostart(@dom_ptr, value)
+      raise Errors::LibError, "Couldn't set domain auto_start" if result.negative?
+    end
+
     # def vcpus
     #   # https://github.com/libvirt/ruby-libvirt/blob/9f71ff5add1f57ffef7cf513b72638d92d9fd84f/ext/libvirt/domain.c#L787
     #   # dominfo = virDomainGetInfo

data/lib/libvirt/ffi.rb

@@ -13,5 +13,7 @@ module Libvirt
     require 'libvirt/ffi/event'
     require 'libvirt/ffi/stream'
     require 'libvirt/ffi/storage'
+    require 'libvirt/ffi/network'
+    require 'libvirt/ffi/interface'
   end
 end