libvirt_ffi 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32cd6d96cd065507a105cffe398c5d6bfa2afd2cd472888f831dd2ad382a48de
-  data.tar.gz: 06ae43ce6d0d65c8d6a5daa0914df5cfa01a3102f467bc7bef3bafaa19e2208a
+  metadata.gz: 79ea563057bb675ad519b6dfafca175b69afe8f9b0dc9b3ab76c32175372eab1
+  data.tar.gz: 86420a7e48c60ff3a4cf3bbd5377d8070facd1e453494b16225a78c7c3e4c898
 SHA512:
-  metadata.gz: 205e7bc1253381af45bcf354b784476acf35f862ba212f6a9b7cdeba3673ed2ae5b73b54ec0a894632e753dd8f1e7ba90cec6a40187c1a0c33df6900f4208c71
-  data.tar.gz: d5754a19f39a9c508722b1cb8d29227d38c62eb1c9f0a7503d94aba33f815180217d4b346c32a1e4638a8b1e2526910ebf6dc6ccffe6ab8e3c415870b629b430
+  metadata.gz: e5c81de1008c0a2c55bcacbbd0a50611d492eba8ee7232fb007f861e011f71053e75434563374c60037a89330b10da5f2873b5fd7359a8ba7bd9a88c011da01d
+  data.tar.gz: b803fae7ff7a85fa744784c89e6566acd43bad33f3229af2f97404e852021005084ca7513afea67f28c9e6e0bc9d2309731f25899bb5b9b5fcb2d8568c46c7d3

data/Gemfile

@@ -10,4 +10,5 @@ group :development do
   gem 'async', '~> 1.24'
   gem 'activesupport'
   gem 'get_process_mem'
+  gem 'gc_tracer'
 end

data/lib/libvirt.rb

@@ -2,6 +2,7 @@
 
 require 'ffi'
 require 'objspace'
+require 'libvirt/domain_callback_storage'
 require 'libvirt/util'
 require 'libvirt/error'
 require 'libvirt/ffi/common'
@@ -24,8 +25,6 @@ module Libvirt
   EVENT_HANDLE_ERROR = 4
   EVENT_HANDLE_HANGUP = 8
 
-  DOMAIN_EVENT_ID_LIFECYCLE = 0
-
   class << self
     def lib_version
       version_ptr = ::FFI::MemoryPointer.new(:ulong)

data/lib/libvirt/connection.rb

@@ -2,20 +2,48 @@
 
 module Libvirt
   class Connection
+    DOMAIN_EVENT_IDS = FFI::Domain.enum_type(:event_id).symbols.dup.freeze
+
+    STORAGE = DomainCallbackStorage.new
+
+    DOMAIN_EVENT_CALLBACKS = FFI::Domain.enum_type(:event_id).symbol_map.map do |name, event_id|
+      func = FFI::Domain.event_callback(event_id) do |conn_ptr, dom_ptr, *args, op_ptr|
+        connection = Connection.load_ref(conn_ptr)
+        domain = Domain.load_ref(dom_ptr)
+        block, opaque = STORAGE.retrieve_from_pointer(op_ptr)
+        block.call(connection, domain, *args, opaque)
+      end
+      [name, func]
+    end.to_h
+
+    def self.load_ref(conn_ptr)
+      ref_result = FFI::Connection.virConnectRef(conn_ptr)
+      raise Error, "Couldn't retrieve connection reference" if ref_result < 0
+      new(nil).send(:set_connection, conn_ptr)
+    end
+
     def initialize(uri)
       @uri = uri
       @conn_ptr = ::FFI::Pointer.new(0)
-      @cb_data = {}
 
       free = ->(obj_id) do
-        STDOUT.puts("finalized Libvirt::Connection obj_id=0x#{obj_id.to_s(16)}, @conn_ptr=#{@conn_ptr}, @uri=#{@uri}, @cb_data=#{@cb_data}")
+        return if @conn_ptr.null?
+        cl_result = FFI::Connection.virConnectClose(@conn_ptr)
+        STDERR.puts "Couldn't close Libvirt::Connection (0x#{obj_id.to_s(16)}) pointer #{@conn_ptr.address}" if cl_result < 0
       end
       ObjectSpace.define_finalizer(self, free)
     end
 
     def open
       @conn_ptr = FFI::Connection.virConnectOpen(@uri)
-      raise Error, "Couldn't connect to #{@uri.inspect}" if @conn_ptr.null?
+      raise Error, "Couldn't open connection to #{@uri.inspect}" if @conn_ptr.null?
+      true
+    end
+
+    def close
+      result = FFI::Connection.virConnectClose(@conn_ptr)
+      raise Error, "Couldn't close connection to #{@uri.inspect}" if result < 0
+      @conn_ptr = ::FFI::Pointer.new(0)
       true
     end
 
@@ -66,42 +94,46 @@ module Libvirt
       ptr.get_array_of_pointer(0, size).map { |dom_ptr| Libvirt::Domain.new(dom_ptr) }
     end
 
-    # @yield conn, dom
+    # @yield conn, dom, *args
     def register_domain_event_callback(event_id, domain = nil, opaque = nil, &block)
-      if event_id == Libvirt::DOMAIN_EVENT_ID_LIFECYCLE
-        cb = FFI::Domain::domain_event_id_lifecycle_callback(&block)
-      else
-        raise Error, "not supported event_id #{event_id.inspect}"
-      end
+      Util.logger.debug { "Libvirt::Connection#register_domain_event_callback event_id=#{event_id}" }
+
+      enum = FFI::Domain.enum_type(:event_id)
+      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
 
       result = FFI::Domain.virConnectDomainEventRegisterAny(
           @conn_ptr,
           domain&.to_ptr,
           event_id,
           cb,
-          opaque&.to_ptr,
-          nil # free_opaque
+          cb_data.pointer,
+          cb_data_free_func
       )
-      raise Error, "Couldn't register domain event callback" if result < 0
+      if result < 0
+        cb_data.pointer.free
+        raise Error, "Couldn't register domain event callback"
+      end
 
-      @cb_data[result] = { event_id: event_id, cb: cb, opaque: opaque }
+      STORAGE.store_struct(
+          cb_data,
+          connection_pointer: @conn_ptr,
+          callback_id: result,
+          cb: block,
+          opaque: opaque
+      )
       result
     end
 
     def deregister_domain_event_callback(callback_id)
-      @cb_data.delete(callback_id)
+      Util.logger.debug { "Libvirt::Connection#deregister_domain_event_callback callback_id=#{callback_id}" }
+
       result = FFI::Domain.virConnectDomainEventDeregisterAny(@conn_ptr, callback_id)
       raise Error, "Couldn't deregister domain event callback" if result < 0
-      true
-    end
 
-    def version
-      version_ptr = ::FFI::MemoryPointer.new(:ulong)
-      result = FFI::Connection.virConnectGetVersion(@conn_ptr, version_ptr)
-      raise Error, "Couldn't get connection version" if result < 0
-      version_number = version_ptr.get_ulong(0)
-      # version_number = FFI::Connection.virConnectGetVersion(@conn_ptr)
-      Libvirt::Util.parse_version(version_number)
+      STORAGE.remove_struct(connection_pointer: @conn_ptr, callback_id: callback_id)
     end
 
     def lib_version
@@ -109,7 +141,6 @@ module Libvirt
       result = FFI::Connection.virConnectGetLibVersion(@conn_ptr, version_ptr)
       raise Error, "Couldn't get connection lib version" if result < 0
       version_number = version_ptr.get_ulong(0)
-      # version_number = FFI::Connection.virConnectGetLibVersion(@conn_ptr)
       Libvirt::Util.parse_version(version_number)
     end
 
@@ -141,6 +172,10 @@ module Libvirt
 
     private
 
+    def set_connection(conn_ptr)
+      @conn_ptr = conn_ptr
+    end
+
     def check_open!
       raise Error, "Connection to #{@uri.inspect} is not open" if @conn_ptr.null?
     end

data/lib/libvirt/domain.rb

@@ -2,11 +2,20 @@
 
 module Libvirt
   class Domain
+
+    def self.load_ref(dom_ptr)
+      ref_result = FFI::Domain.virDomainRef(dom_ptr)
+      raise Error, "Couldn't retrieve domain reference" if ref_result < 0
+      new(dom_ptr)
+    end
+
     def initialize(dom_ptr)
       @dom_ptr = dom_ptr
 
       free = ->(obj_id) do
-        STDOUT.puts("finalized Libvirt::Domain obj_id=0x#{obj_id.to_s(16)}, @dom_ptr=#{@dom_ptr},")
+        return unless @dom_ptr
+        fr_result = FFI::Domain.virDomainFree(@dom_ptr)
+        STDERR.puts "Couldn't free Libvirt::Domain (0x#{obj_id.to_s(16)}) pointer #{@dom_ptr.address}" if fr_result < 0
       end
       ObjectSpace.define_finalizer(self, free)
     end
@@ -64,5 +73,11 @@ module Libvirt
       # free pointer required
       mime_type
     end
+
+    def free_domain
+      result = FFI::Domain.virDomainFree(@dom_ptr)
+      raise Error, "Couldn't free domain" if result < 0
+      @dom_ptr = nil
+    end
   end
 end

data/lib/libvirt/domain_callback_storage.rb

@@ -0,0 +1,65 @@
+module Libvirt
+  class DomainCallbackStorage
+
+    class CallbackDataStruct < ::FFI::Struct
+      layout :connection_pointer, :pointer,
+             :callback_id, :int
+    end
+
+    def initialize
+      @inner_storage = Hash.new { |h, key| h[key] = {} }
+    end
+
+    # @return [Array<2>]
+    #   cb_data [Libvirt::DomainCallbackStorage::CallbackDataStruct],
+    #   cb_data_free_func [FFI::Function]
+    def allocate_struct
+      Util.logger.debug { "Libvirt::DomainCallbackStorage#allocate_struct" }
+
+      cb_data_ptr = ::FFI::MemoryPointer.new(:char, CallbackDataStruct.size, false)
+      cb_data = CallbackDataStruct.new(cb_data_ptr)
+      cb_data_free_func = ::FFI::Function.new(:void, [:pointer]) do |pointer|
+        Util.logger.debug { "Libvirt::DomainCallbackStorage cb_data_free_func triggered" }
+        remove_struct(pointer: pointer)
+      end
+      [cb_data, cb_data_free_func]
+    end
+
+    def store_struct(cb_data, connection_pointer:, callback_id:, cb:, opaque:)
+      Util.logger.debug { "Libvirt::DomainCallbackStorage#store_struct" }
+
+      cb_data[:connection_pointer] = connection_pointer
+      cb_data[:callback_id] = callback_id
+      @inner_storage[connection_pointer.address][callback_id] = { cb: cb, opaque: opaque, pointer: cb_data.pointer }
+    end
+
+    def remove_struct(pointer: nil, connection_pointer: nil, callback_id: nil)
+      Util.logger.debug { "Libvirt::DomainCallbackStorage#remove_struct pointer=#{pointer}, connection_pointer=#{connection_pointer}, callback_id=#{callback_id}," }
+
+      if pointer
+        cb_data_struct = CallbackDataStruct.new(pointer)
+        connection_pointer = cb_data_struct[:connection_pointer]
+        callback_id = cb_data_struct[:callback_id]
+      end
+
+      cb_data = @inner_storage[connection_pointer.address].delete(callback_id)
+      pointer ||= cb_data[:pointer]
+      @inner_storage.delete(connection_pointer.address) if @inner_storage[connection_pointer.address].empty?
+
+      #pointer.free
+      cb_data[:opaque]
+    end
+
+    # @param [::FFI::Pointer]
+    # @return [Array<2>] cb [Proc], opaque [Object]
+    def retrieve_from_pointer(pointer)
+      Util.logger.debug { "Libvirt::DomainCallbackStorage#retrieve_from_pointer pointer=#{pointer}," }
+
+      cb_data_struct = CallbackDataStruct.new(pointer)
+      connection_pointer = cb_data_struct[:connection_pointer]
+      callback_id = cb_data_struct[:callback_id]
+      cb_data = @inner_storage[connection_pointer.address][callback_id]
+      [cb_data[:cb], cb_data[:opaque]]
+    end
+  end
+end

data/lib/libvirt/ffi/connection.rb

@@ -79,6 +79,16 @@ module Libvirt
       #   virConnectPtr conn
       # )
       attach_function :virConnectGetCapabilities, [:pointer],  :string # strptr ?
+
+      # int	virConnectClose	(
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectClose, [:pointer], :int
+
+      # int	virConnectRef	(
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectRef, [:pointer], :int
     end
   end
 end

data/lib/libvirt/ffi/domain.rb

@@ -8,6 +8,85 @@ module Libvirt
 
       UUID_STRING_BUFLEN = 0x80 # RFC4122
 
+      # enum virDomainEventID
+      enum :event_id, [
+          :LIFECYCLE, 0,              # (0x0) virConnectDomainEventCallback
+          :REBOOT, 1,                 # (0x1) virConnectDomainEventGenericCallback
+          :RTC_CHANGE, 2,             # (0x2) virConnectDomainEventRTCChangeCallback
+          :WATCHDOG, 3,               # (0x3) virConnectDomainEventWatchdogCallback
+          :IO_ERROR, 4,               # (0x4) virConnectDomainEventIOErrorCallback
+          :GRAPHICS, 5,               # (0x5) virConnectDomainEventGraphicsCallback
+          :IO_ERROR_REASON, 6,        # (0x6) virConnectDomainEventIOErrorReasonCallback
+          :CONTROL_ERROR, 7,          # (0x7) virConnectDomainEventGenericCallback
+          :BLOCK_JOB, 8,              # (0x8) virConnectDomainEventBlockJobCallback
+          :DISK_CHANGE, 9,            # (0x9) virConnectDomainEventDiskChangeCallback
+          :TRAY_CHANGE, 10,           # (0xa) virConnectDomainEventTrayChangeCallback
+          :PMWAKEUP, 11,              # (0xb) virConnectDomainEventPMWakeupCallback
+          :PMSUSPEND, 12,             # (0xc) virConnectDomainEventPMSuspendCallback
+          :BALLOON_CHANGE, 13,        # (0xd) virConnectDomainEventBalloonChangeCallback
+          :PMSUSPEND_DISK, 14,        # (0xe) virConnectDomainEventPMSuspendDiskCallback
+          :DEVICE_REMOVED, 15,        # (0xf) virConnectDomainEventDeviceRemovedCallback
+          :BLOCK_JOB_2, 16,           # (0x10) virConnectDomainEventBlockJobCallback
+          :TUNABLE, 17,               # (0x11) virConnectDomainEventTunableCallback
+          :AGENT_LIFECYCLE, 18,       # (0x12) virConnectDomainEventAgentLifecycleCallback
+          :DEVICE_ADDED, 19,          # (0x13) virConnectDomainEventDeviceAddedCallback
+          :MIGRATION_ITERATION, 20,   # (0x14) virConnectDomainEventMigrationIterationCallback
+          :JOB_COMPLETED, 21,         # (0x15) virConnectDomainEventJobCompletedCallback
+          :DEVICE_REMOVAL_FAILED, 22, # (0x16) virConnectDomainEventDeviceRemovalFailedCallback
+          :METADATA_CHANGE, 23,       # (0x17) virConnectDomainEventMetadataChangeCallback
+          :BLOCK_THRESHOLD, 24        # (0x18) virConnectDomainEventBlockThresholdCallback
+      ]
+
+      EVENT_ID_TO_CALLBACK = {
+          LIFECYCLE: :virConnectDomainEventCallback,
+          REBOOT: :virConnectDomainEventGenericCallback,
+          RTC_CHANGE: :virConnectDomainEventRTCChangeCallback,
+          WATCHDOG: :virConnectDomainEventWatchdogCallback,
+          IO_ERROR: :virConnectDomainEventIOErrorCallback,
+          GRAPHICS: :virConnectDomainEventGraphicsCallback,
+          IO_ERROR_REASON: :virConnectDomainEventIOErrorReasonCallback,
+          CONTROL_ERROR: :virConnectDomainEventGenericCallback,
+          BLOCK_JOB: :virConnectDomainEventBlockJobCallback,
+          DISK_CHANGE: :virConnectDomainEventDiskChangeCallback,
+          TRAY_CHANGE: :virConnectDomainEventTrayChangeCallback,
+          PMWAKEUP: :virConnectDomainEventPMWakeupCallback,
+          PMSUSPEND: :virConnectDomainEventPMSuspendCallback,
+          BALLOON_CHANGE: :virConnectDomainEventBalloonChangeCallback,
+          PMSUSPEND_DISK: :virConnectDomainEventPMSuspendDiskCallback,
+          DEVICE_REMOVED: :virConnectDomainEventDeviceRemovedCallback,
+          BLOCK_JOB_2: :virConnectDomainEventBlockJobCallback,
+          TUNABLE: :virConnectDomainEventTunableCallback,
+          AGENT_LIFECYCLE: :virConnectDomainEventAgentLifecycleCallback,
+          DEVICE_ADDED: :virConnectDomainEventDeviceAddedCallback,
+          MIGRATION_ITERATION: :virConnectDomainEventMigrationIterationCallback,
+          JOB_COMPLETED: :virConnectDomainEventJobCompletedCallback,
+          DEVICE_REMOVAL_FAILED: :virConnectDomainEventDeviceRemovalFailedCallback,
+          METADATA_CHANGE: :virConnectDomainEventMetadataChangeCallback,
+          BLOCK_THRESHOLD: :virConnectDomainEventBlockThresholdCallback
+      }
+
+      # enum virDomainState
+      enum :state, [
+          :NOSTATE, 0x0,    # no state
+          :RUNNING, 0x1,    # the domain is running
+          :BLOCKED, 0x2,    # the domain is blocked on resource
+          :PAUSED, 0x3,     # the domain is paused by user
+          :SHUTDOWN, 0x4,   # the domain is being shut down
+          :SHUTOFF, 0x5,    # the domain is shut off
+          :CRASHED, 0x6,    # the domain is crashed
+          :PMSUSPENDED, 0x7 # the domain is suspended by guest power management
+      ]
+
+      # int	virDomainFree	(
+      #   virDomainPtr domain
+      # )
+      attach_function :virDomainFree, [:pointer], :int
+
+      # int	virDomainRef (
+      #   virDomainPtr domain
+      # )
+      attach_function :virDomainRef, [:pointer], :int
+
       # int	virConnectDomainEventRegisterAny(
       #   virConnectPtr conn,
       # 	virDomainPtr dom,
@@ -25,6 +104,12 @@ module Libvirt
           :pointer
       ], :int
 
+      # int	virConnectDomainEventDeregisterAny (
+      #   virConnectPtr conn,
+      # 	int callbackID
+      # )
+      attach_function :virConnectDomainEventDeregisterAny, [:pointer, :int], :int
+
       # int	virConnectListAllDomains (
       #   virConnectPtr conn,
       # 	virDomainPtr **domains,
@@ -32,39 +117,6 @@ module Libvirt
       # )
       attach_function :virConnectListAllDomains, [:pointer, :pointer, :uint], :int
 
-      # enum virDomainState {
-      #   VIR_DOMAIN_NOSTATE 	= 	0 (0x0)
-      #   no state
-      #   VIR_DOMAIN_RUNNING 	= 	1 (0x1)
-      #   the domain is running
-      #   VIR_DOMAIN_BLOCKED 	= 	2 (0x2)
-      #   the domain is blocked on resource
-      #   VIR_DOMAIN_PAUSED 	= 	3 (0x3)
-      #   the domain is paused by user
-      #   VIR_DOMAIN_SHUTDOWN 	= 	4 (0x4)
-      #   the domain is being shut down
-      #   VIR_DOMAIN_SHUTOFF 	= 	5 (0x5)
-      #   the domain is shut off
-      #   VIR_DOMAIN_CRASHED 	= 	6 (0x6)
-      #   the domain is crashed
-      #   VIR_DOMAIN_PMSUSPENDED 	= 	7 (0x7)
-      #   the domain is suspended by guest power management
-      #   VIR_DOMAIN_LAST 	= 	8 (0x8)
-      # NB: this enum value will increase over time as new events are added to the libvirt API.
-      # It reflects the last state supported by this version of the libvirt API.
-      # }
-      enum :states, [
-          :no_state, 0x0,
-          :running, 0x1,
-          :blocked, 0x2,
-          :paused, 0x3,
-          :shutdown, 0x4,
-          :shutoff, 0x5,
-          :crashed, 0x6,
-          :pm_suspended, 0x7,
-          :last, 0x8
-      ]
-
       # int	virDomainGetState	(
       #   virDomainPtr domain,
       # 	int *state,
@@ -124,10 +176,343 @@ module Libvirt
       # 	int detail,
       # 	void * opaque
       # )
-      def self.domain_event_id_lifecycle_callback(&block)
-        ::FFI::Function.new(:int, [:pointer, :pointer, :int, :int]) do |_conn, dom, event, detail, op|
-          Util.log(:debug) { "DOMAIN_EVENT_CALLBACK LIFECYCLE dom=#{dom}, event=#{event}, detail=#{detail}, op=#{op}" }
-          block.call(dom, event, detail, op)
+      callback :virConnectDomainEventCallback, [:pointer, :pointer, :int, :int, :pointer], :int
+
+      # typedef void (*virConnectDomainEventGenericCallback) (
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventGenericCallback, [:pointer, :pointer, :pointer], :void
+
+      # typedef void (*virConnectDomainEventRTCChangeCallback) (
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	long long utcoffset,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventRTCChangeCallback, [
+          :pointer,
+          :pointer,
+          :long_long,
+          :pointer
+      ], :void
+
+      # typedef void (*virConnectDomainEventWatchdogCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int action,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventWatchdogCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void (*virConnectDomainEventIOErrorCallback) (
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * srcPath,
+      # 	const char * devAlias,
+      # 	int action,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventIOErrorCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :string,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void (*virConnectDomainEventGraphicsCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int phase,
+      # 	const virDomainEventGraphicsAddress * local,
+      # 	const virDomainEventGraphicsAddress * remote,
+      # 	const char * authScheme,
+      # 	const virDomainEventGraphicsSubject * subject,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventGraphicsCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          # virDomainEventGraphicsAddress
+          # virDomainEventGraphicsAddress
+          :string,
+          # virDomainEventGraphicsSubject
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventIOErrorReasonCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * srcPath,
+      # 	const char * devAlias,
+      # 	int action,
+      # 	const char * reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventIOErrorReasonCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :string,
+          :int,
+          :string,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventBlockJobCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * disk,
+      # 	int type,
+      # 	int status,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventBlockJobCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :int,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventDiskChangeCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * oldSrcPath,
+      # 	const char * newSrcPath,
+      # 	const char * devAlias,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventDiskChangeCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :string,
+          :string,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventTrayChangeCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * devAlias,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventTrayChangeCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventPMWakeupCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventPMWakeupCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventPMSuspendCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventPMSuspendCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventBalloonChangeCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	unsigned long long actual,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventBalloonChangeCallback, [
+          :pointer,
+          :pointer,
+          :ulong_long,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventPMSuspendDiskCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventPMSuspendDiskCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventDeviceRemovedCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * devAlias,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventDeviceRemovedCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventTunableCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	virTypedParameterPtr params,
+      # 	int nparams,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventTunableCallback, [
+          :pointer,
+          :pointer,
+          # virTypedParameterPtr
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventAgentLifecycleCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int state,
+      # 	int reason,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventAgentLifecycleCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventDeviceAddedCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * devAlias,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventDeviceAddedCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventMigrationIterationCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int iteration,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventMigrationIterationCallback, [
+          :pointer,
+          :pointer,
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventJobCompletedCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	virTypedParameterPtr params,
+      # 	int nparams,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventJobCompletedCallback, [
+          :pointer,
+          :pointer,
+          # virTypedParameterPtr
+          :int,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventDeviceRemovalFailedCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * devAlias,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventDeviceRemovalFailedCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventMetadataChangeCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	int type,
+      # 	const char * nsuri,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventMetadataChangeCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :pointer
+      ], :void
+
+      # typedef void	(*virConnectDomainEventBlockThresholdCallback)	(
+      #   virConnectPtr conn,
+      # 	virDomainPtr dom,
+      # 	const char * dev,
+      # 	const char * path,
+      # 	unsigned long long threshold,
+      # 	unsigned long long excess,
+      # 	void * opaque
+      # )
+      callback :virConnectDomainEventBlockThresholdCallback, [
+          :pointer,
+          :pointer,
+          :string,
+          :string,
+          :ulong_long,
+          :ulong_long,
+          :pointer
+      ], :void
+
+      # @param event_id [Integer]
+      # @yield connect_ptr, domain_ptr, *args, opaque_ptr
+      def self.event_callback(event_id, &block)
+        event_id_sym = enum_type(:event_id)[event_id]
+        callback_name = EVENT_ID_TO_CALLBACK.fetch(event_id_sym)
+        callback_info = find_type(callback_name)
+        ::FFI::Function.new(callback_info.result_type, callback_info.param_types) do |*args|
+          Util.log(:debug) { "Libvirt::Domain #{event_id_sym} CALLBACK #{args.map(&:to_s).join(', ')}," }
+          block.call(*args)
+          # Only callback for lifecycle must return 0.
+          # Return value of other callbacks are ignored.
+          # So we just pass zero everywhere.
           0
         end
       end

data/lib/libvirt/stream.rb

@@ -12,15 +12,15 @@ module Libvirt
       @opaque = nil
 
       free = ->(obj_id) do
-        STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)}, @stream_ptr=#{@stream_ptr}, @cb=#{@cb},")
-        if @stream_ptr && @cb
-          rm = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
-          STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} rm=#{rm}")
-          ab = FFI::Stream.virStreamAbort(@stream_ptr)
-          STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} ab=#{ab}")
+        return unless @stream_ptr
+        if @cb
+          rcb_result = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
+          STDERR.puts("Couldn't remove callback Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if rcb_result < 0
+          ab_result = FFI::Stream.virStreamAbort(@stream_ptr)
+          STDERR.puts("Couldn't abort Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if ab_result < 0
         end
-        fr = FFI::Stream.virStreamFree(@stream_ptr) if @stream_ptr
-        STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} fr=#{fr}")
+        fr_result = FFI::Stream.virStreamFree(@stream_ptr)
+        STDERR.puts("Couldn't free Libvirt::Stream (0x#{obj_id.to_s(16)}) pointer #{@stream_ptr.address}") if fr_result < 0
       end
       ObjectSpace.define_finalizer(self, free)
     end
@@ -77,6 +77,14 @@ module Libvirt
       @opaque = nil
     end
 
+    def free_stream
+      result = FFI::Stream.virStreamFree(@stream_ptr)
+      raise Error, "Couldn't free stream event callback" if result < 0
+      @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)

data/lib/libvirt/util.rb

@@ -29,6 +29,20 @@ module Libvirt
         "#{major}.#{minor}.#{release}"
       end
 
+      # @param enum [FFI::Enum]
+      # @param value [Symbol, Integer]
+      # @return [Array] event_id, event_id_sym
+      # @raise ArgumentError
+      def parse_enum(enum, value)
+        if value.is_a?(Symbol)
+          raise ArgumentError, 'invalid enum value' unless enum.symbols.include?(value)
+          return [enum.find(value), value]
+        end
+
+        raise ArgumentError, 'invalid enum value' unless enum.symbol_map.values.include?(value)
+        [value, enum.symbol_map[value]]
+      end
+
     end
   end
 end

data/lib/libvirt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Libvirt
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/test_usage/test_event_loop.rb

@@ -6,16 +6,26 @@ require 'logger'
 require 'active_support/all'
 require 'async'
 require 'get_process_mem'
+require 'gc_tracer'
 
 require_relative 'support/libvirt_async'
 require_relative 'support/log_formatter'
 
+GC::Tracer.start_logging(
+    nil,
+    gc_stat: false,
+    gc_latest_gc_info: false,
+    rusage: false,
+    events: %i[end_mark end_sweep]
+)
+
 Libvirt.logger = Logger.new(STDOUT, formatter: LogFormatter.new)
 Libvirt.logger.level = ENV['DEBUG'] ? :debug : :info
 
 IMPL = LibvirtAsync::Implementations.new
 CONNS = []
 DOMS = []
+CB_IDS = []
 
 Async do
   ASYNC_REACTOR = Async::Task.current.reactor
@@ -47,9 +57,13 @@ Async do
   puts "NodeInfo threads #{node_info.threads.inspect}"
   puts "NodeInfo memory #{node_info.memory.inspect}"
 
-  c.register_domain_event_callback(Libvirt::DOMAIN_EVENT_ID_LIFECYCLE, nil) do |dom, event, detail, opaque|
-    Libvirt.logger.info { "DOMAIN_EVENT_ID_LIFECYCLE user dom=#{dom}, event=#{event}, detail=#{detail}, opaque=#{opaque}" }
+  cb_ids = Libvirt::Connection::DOMAIN_EVENT_IDS.map do |event_id|
+    op = OpenStruct.new(a: 'b', event_id: event_id)
+    c.register_domain_event_callback(event_id, nil, op) do |conn, dom, *args, opaque|
+      Libvirt.logger.info { "DOMAIN EVENT #{event_id} conn=#{conn}, dom=#{dom}, args=#{args}, opaque=#{opaque}" }
+    end
   end
+  CB_IDS.concat(cb_ids)
 
   puts "domains qty #{c.list_all_domains_qty}"
 
@@ -57,12 +71,6 @@ Async do
   DOMS.concat(domains)
   puts "Domains (#{domains.size}): #{domains}"
 
-  domains.each_with_index do |domain, index|
-    c.register_domain_event_callback(Libvirt::DOMAIN_EVENT_ID_LIFECYCLE, domain) do |dom, event, detail, opaque|
-      Libvirt.logger.info { "DOMAIN_EVENT_CALLBACK LIFECYCLE user##{index} dom=#{dom}, event=#{event}, detail=#{detail}, opaque=#{opaque}" }
-    end
-  end
-
   d = domains.first
   puts "Domain uuid #{d.uuid.inspect}"
   puts "Domain name #{d.name.inspect}"
@@ -75,10 +83,27 @@ Async do
   #   LibvirtAsync::Util.create_task(nil, ASYNC_REACTOR) { IMPL.print_debug_info }.run
   # end
 
-  # ASYNC_REACTOR.every(5) do
-  #   Libvirt.logger.info { "MEM USAGE: #{GetProcessMem.new.mb} MB" }
-  #   Libvirt.logger.info { "GC.start" }
-  #   GC.start
-  #   Libvirt.logger.info { "MEM USAGE: #{GetProcessMem.new.mb} MB" }
-  # end
+  ASYNC_REACTOR.every(5) do
+    Libvirt.logger.info { "MEM USAGE: #{GetProcessMem.new.mb} MB" }
+    # Libvirt.logger.info { "GC.start" }
+    # GC.start
+    # Libvirt.logger.info { "MEM USAGE: #{GetProcessMem.new.mb} MB" }
+  end
+
+  ASYNC_REACTOR.after(20) do
+    LibvirtAsync::Util.create_task(nil, ASYNC_REACTOR) do
+
+      c = CONNS.first
+      CB_IDS.each do |callback_id|
+        opaque = c.deregister_domain_event_callback(callback_id)
+        puts "Retrieved opaque #{opaque}"
+      end
+      Libvirt.logger.info { 'Cleaning up!' }
+      CONNS = []
+      DOMS = []
+      CB_IDS = []
+      GC.start
+
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libvirt_ffi
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Denis Talakevich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-28 00:00:00.000000000 Z
+date: 2020-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -45,6 +45,7 @@ files:
 - lib/libvirt.rb
 - lib/libvirt/connection.rb
 - lib/libvirt/domain.rb
+- lib/libvirt/domain_callback_storage.rb
 - lib/libvirt/error.rb
 - lib/libvirt/event.rb
 - lib/libvirt/ffi/common.rb