libvirt_ffi 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e90f40ae66ad4112b924b384083ffb6c4d570ef216ad5c72d7c3d20a043d626
-  data.tar.gz: c8b476a622973d27d269d136a1040bee40b7358c334361b12a0c5a0fcc703598
+  metadata.gz: 5f84407d986359b92b8ad0eaf854f85d098e93835d218a69a9a346f864176c9d
+  data.tar.gz: c339098e1c00e91f229f814eb399e1ba1980673428d1bf78c565a79080d5456e
 SHA512:
-  metadata.gz: 1d1f5d665e72e42bed01e86eed59201d30158a4977651667d2d6bb592381d5fdd90dc19f75ce5c47b98234408321824b50155b984ee25f08d6d399e398238d18
-  data.tar.gz: 9bb95047323c0667af10a2d74884ffe749514303635853185f439582074226a702f7b99afa653cd76096c0bea2d7bb77a4596b07e94f3f8e34edb16ccfc886a7
+  metadata.gz: ef9bf3632b42bc37324dbd9cc382b908f6320cdb7a8c16c91bd05a2b5c4f402d2fb675079c3ab0fce9157ad4557caa4b5bd37044841b1ce558c7d2eaf9901502
+  data.tar.gz: 504c1ac8e2c3df785f8754e2abc3bc5643dc7c5c553a8f10793f9e14ea40da9c07961fb510b6a4ae701f2d9df66f689acec0cf09d593a7d23d663e52703b5309

data/lib/libvirt.rb

@@ -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

@@ -4,9 +4,11 @@ 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
 
     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|
@@ -35,6 +37,19 @@ module Libvirt
       [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)
@@ -160,6 +175,60 @@ 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}" }
 
@@ -186,6 +255,17 @@ module Libvirt
       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
     def register_domain_event_callback(event_id, domain = nil, opaque = nil, &block)
       dbg { "#register_domain_event_callback event_id=#{event_id}" }
@@ -275,14 +355,47 @@ module Libvirt
       true
     end
 
-    def deregister_close_callback
-      dbg { '#deregister_close_callback' }
+    def register_network_event_callback(event_id, network = nil, opaque = nil, &block)
+      dbg { "#register_network_event_callback event_id=#{event_id}" }
 
-      result = FFI::Host.virConnectUnregisterCloseCallback(@conn_ptr, CLOSE_CALLBACK)
-      raise Errors::LibError, "Couldn't deregister close callback" if result.negative?
+      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)
 
-      # virConnectUnregisterCloseCallback will call free func
-      # So we don't need to remove object from CLOSE_STORAGE here.
+      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
 
@@ -331,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

@@ -61,7 +61,7 @@ module Libvirt
     def auto_start
       value = ::FFI::MemoryPointer.new(:int)
       result = FFI::Domain.virDomainGetAutostart(@dom_ptr, value)
-      raise Errors::LibError, "Couldn't get domain uuid" if result.negative?
+      raise Errors::LibError, "Couldn't get domain auto_start" if result.negative?
 
       value.read_int == 1
     end
@@ -71,7 +71,7 @@ module Libvirt
     def set_auto_start(value)
       value = value ? 1 : 0
       result = FFI::Domain.virDomainSetAutostart(@dom_ptr, value)
-      raise Errors::LibError, "Couldn't get domain uuid" if result.negative?
+      raise Errors::LibError, "Couldn't set domain auto_start" if result.negative?
     end
 
     # def vcpus

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

data/lib/libvirt/ffi/interface.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Interface
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      ## Variables
+
+      ## Enums
+
+      # enum virConnectListAllInterfacesFlags
+      enum :list_all_flags, [
+          :INACTIVE, 0x1,
+          :ACTIVE, 0x2
+      ]
+
+      # enum virInterfaceXMLFlags
+      enum :xml_flags, [
+          :INACTIVE, 0x1 # dump inactive interface information
+      ]
+
+      ## Functions
+
+      # int virConnectListAllInterfaces (
+      #   virConnectPtr conn,
+      #   virInterfacePtr ** ifaces,
+      #   unsigned int flags
+      # )
+      attach_function :virConnectListAllInterfaces,
+                      [:pointer, :pointer, :list_all_flags],
+                      :int
+
+      # int virConnectListDefinedInterfaces (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListDefinedInterfaces,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int virConnectListInterfaces (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListInterfaces,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int virConnectNumOfDefinedInterfaces (virConnectPtr conn)
+      attach_function :virConnectNumOfDefinedInterfaces,
+                      [:pointer],
+                      :int
+
+      # int virConnectNumOfInterfaces (virConnectPtr conn)
+      attach_function :virConnectNumOfInterfaces,
+                      [:pointer],
+                      :int
+
+      # int virInterfaceChangeBegin (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeBegin,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceChangeCommit (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeCommit,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceChangeRollback (
+      #   virConnectPtr conn,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceChangeRollback,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceCreate (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceCreate,
+                      [:pointer, :uint],
+                      :int
+
+      # virInterfacePtr  virInterfaceDefineXML (
+      #   virConnectPtr conn,
+      #   const char * xml,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceDefineXML,
+                      [:pointer, :string, :uint],
+                      :pointer
+
+      # int virInterfaceDestroy (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceDestroy,
+                      [:pointer, :uint],
+                      :int
+
+      # int virInterfaceFree (virInterfacePtr iface)
+      attach_function :virInterfaceFree,
+                      [:pointer],
+                      :int
+
+      # virConnectPtr virInterfaceGetConnect (virInterfacePtr iface)
+      attach_function :virInterfaceGetConnect,
+                      [:pointer],
+                      :int
+
+      # const char * virInterfaceGetMACString (virInterfacePtr iface)
+      attach_function :virInterfaceGetMACString,
+                      [:pointer],
+                      :string
+
+      # const char * virInterfaceGetName (virInterfacePtr iface)
+      attach_function :virInterfaceGetName,
+                      [:pointer],
+                      :string
+
+      # char * virInterfaceGetXMLDesc (
+      #   virInterfacePtr iface,
+      #   unsigned int flags
+      # )
+      attach_function :virInterfaceGetXMLDesc,
+                      [:pointer, :uint],
+                      :string
+
+      # int virInterfaceIsActive (virInterfacePtr iface)
+      attach_function :virInterfaceIsActive,
+                      [:pointer],
+                      :int
+
+      # virInterfacePtr virInterfaceLookupByMACString (
+      #   virConnectPtr conn,
+      #   const char * macstr
+      # )
+      attach_function :virInterfaceLookupByMACString,
+                      [:pointer, :string],
+                      :pointer
+
+      # virInterfacePtr virInterfaceLookupByName (
+      #   virConnectPtr conn,
+      #   const char * name
+      # )
+      attach_function :virInterfaceLookupByName,
+                      [:pointer, :string],
+                      :pointer
+
+      # int virInterfaceRef (virInterfacePtr iface)
+      attach_function :virInterfaceRef,
+                      [:pointer],
+                      :int
+
+      # int virInterfaceUndefine (virInterfacePtr iface)
+      attach_function :virInterfaceUndefine,
+                      [:pointer],
+                      :int
+
+      ## Helpers
+    end
+  end
+end