libvirt_ffi 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3644f17ca84d47cdb1137cc70206ba1f21e6ff9134cfce63a3e285699da7f209
-  data.tar.gz: 0ed561ac6371b32ec98b1ff0f4ff8baee4896781eeee7e21ac0af83aeb71e5f0
+  metadata.gz: 86eb83fbee1eb9d405515e1112beecf735861a1149aab08468713489f5fa6276
+  data.tar.gz: 847652924525076788903cd2e64a0d0fca58760fd57bf934c79d865e538d132f
 SHA512:
-  metadata.gz: 230412ae8c751eda2e21459f86c5fd82588c9e4288061fa5137166f92cc82b41045f66a5d643917a6cca0015b61820084e179318ba2730f3f5fefdee985f1923
-  data.tar.gz: d47c4efedea90cf797e212603da0304250f3a09360e7cde73c7509dd044d91ee36be52ec5f2a86622701e744d85416d8c231c325b0435078c22d2524f9d57688
+  metadata.gz: d54fdb1f3131d4a23f90126773a40f8829b5a9282bae0cc22c81613dd846970d4a1f32ae899856d0993f5fc61d833d6fc1f84896d9bc2e5dab23c964326b62cb
+  data.tar.gz: f092fa8e8a0c3f220a4c8fff8ad530f4b5b740f5f92c4b21bca9c1157e93ae0f572c9547b6d922c61f6629348f6087ac37c2541551713f5ab3934e5a26e4442f

data/.rubocop.yml

@@ -0,0 +1,78 @@
+AllCops:
+  DisplayCopNames: true
+  TargetRubyVersion: 2.5
+  Exclude:
+    - vendor/**/*
+    - tmp/**/*
+    - pkg/*
+    - test_usage/**/*.rb
+
+Layout/LineLength:
+  Max: 180
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+Naming/MethodParameterName:
+  AllowedNames:
+    - id
+    - cb
+    - fd
+
+Naming/AccessorMethodName:
+  Enabled: false
+
+Style/HashEachMethods:
+  Enabled: true
+
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Layout/MultilineOperationIndentation:
+  Enabled: false
+
+Layout/FirstHashElementIndentation:
+  Enabled: false
+
+Layout/FirstArrayElementIndentation:
+  Enabled: false
+
+Layout/FirstArgumentIndentation:
+  Enabled: false
+
+Layout/ClosingParenthesisIndentation:
+  Enabled: false
+
+Layout/ArgumentAlignment:
+  Enabled: false
+

data/Gemfile

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in libvirt.gemspec
 gemspec
 
-gem 'rake', '~> 12.0'
 gem 'minitest', '~> 5.0'
+gem 'rake', '~> 12.0'
+
+gem 'nokogiri'
 
 group :development do
-  gem 'async', '~> 1.24'
   gem 'activesupport'
-  gem 'get_process_mem'
+  gem 'async', '~> 1.24'
   gem 'gc_tracer'
+  gem 'get_process_mem'
 end

data/Rakefile

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rubocop/rake_task'
 
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
@@ -7,4 +10,6 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task default: :test
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:rubocop, :test]

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'libvirt'

data/exe/libvirt

@@ -1,3 +1,4 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'libvirt'

data/lib/libvirt/base_info.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class BaseInfo
+    # Abstract Base class for info
+
+    class << self
+      attr_accessor :_struct_class
+
+      # @param [Class<FFI::Struct>]
+      def struct_class(klass)
+        self._struct_class = klass
+        klass.members.each do |attr|
+          define_method(attr) { @struct[attr] }
+        end
+      end
+    end
+
+    def initialize(pointer)
+      raise ArgumentError, "Can't initialize base class #{self.class}" if self.class == BaseInfo
+
+      @ptr = pointer
+      @struct = self.class._struct_class.new(pointer)
+    end
+
+    def [](attr)
+      @struct[attr]
+    end
+
+    def to_h
+      @struct.members.map { |attr| [attr, @struct[attr]] }.to_h
+    end
+  end
+end

data/lib/libvirt/connection.rb

@@ -6,43 +6,49 @@ module Libvirt
 
     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|
+    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|
         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
+      [event_id_sym, func]
+    end.to_h.freeze
 
     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)
+      ref_result = FFI::Host.virConnectRef(conn_ptr)
+      raise Errors::LibError, "Couldn't retrieve connection reference" if ref_result.negative?
+
+      new(nil).tap { |r| r.send(:set_connection, conn_ptr) }
     end
 
     def initialize(uri)
       @uri = uri
       @conn_ptr = ::FFI::Pointer.new(0)
+      @close_data = nil
 
       free = ->(obj_id) do
+        Util.log(:debug) { "Finalize Libvirt::Connection 0x#{obj_id.to_s(16)} @conn_ptr=#{@conn_ptr}," }
         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
+
+        cl_result = FFI::Host.virConnectClose(@conn_ptr)
+        warn "Couldn't close Libvirt::Connection (0x#{obj_id.to_s(16)}) pointer #{@conn_ptr.address}" if cl_result.negative?
       end
       ObjectSpace.define_finalizer(self, free)
     end
 
     def open
-      @conn_ptr = FFI::Connection.virConnectOpen(@uri)
-      raise Error, "Couldn't open connection to #{@uri.inspect}" if @conn_ptr.null?
+      @conn_ptr = FFI::Host.virConnectOpen(@uri)
+      raise Errors::LibError, "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
+      result = FFI::Host.virConnectClose(@conn_ptr)
+      raise Errors::LibError, "Couldn't close connection to #{@uri.inspect}" if result.negative?
+
       @conn_ptr = ::FFI::Pointer.new(0)
       true
     end
@@ -59,16 +65,18 @@ module Libvirt
       check_open!
 
       version_ptr = ::FFI::MemoryPointer.new(:ulong)
-      result = FFI::Connection.virConnectGetVersion(@conn_ptr, version_ptr)
-      raise Error, "Couldn't retrieve connection version" if result < 0
+      result = FFI::Host.virConnectGetVersion(@conn_ptr, version_ptr)
+      raise Errors::LibError, "Couldn't retrieve connection version" if result.negative?
+
       version_number = version_ptr.get_ulong(0)
-      Libvirt::Util::parse_version(version_number)
+      Util.parse_version(version_number)
     end
 
     def set_keep_alive(interval, count)
-      result = FFI::Connection.virConnectSetKeepAlive(@conn_ptr, interval, count)
-      raise Error, "Couldn't set connection keep_alive" if result < 0
-      result == 0
+      result = FFI::Host.virConnectSetKeepAlive(@conn_ptr, interval, count)
+      raise Errors::LibError, "Couldn't set connection keep_alive" if result.negative?
+
+      result.zero?
     end
 
     def to_s
@@ -81,19 +89,60 @@ module Libvirt
 
     def list_all_domains_qty(flags = 0)
       result = FFI::Domain.virConnectListAllDomains(@conn_ptr, nil, flags)
-      raise Error, "Couldn't retrieve domains qty with flags #{flags.to_s(16)}" if result < 0
+      raise Errors::LibError, "Couldn't retrieve domains qty with flags #{flags.to_s(16)}" if result.negative?
+
       result
     end
 
     def list_all_domains(flags = 0)
       size = list_all_domains_qty(flags)
+      return [] if size.zero?
+
       domains_ptr = ::FFI::MemoryPointer.new(:pointer, size)
       result = FFI::Domain.virConnectListAllDomains(@conn_ptr, domains_ptr, flags)
-      raise Error, "Couldn't retrieve domains list with flags #{flags.to_s(16)}" if result < 0
+      raise Errors::LibError, "Couldn't retrieve domains list with flags #{flags.to_s(16)}" if result.negative?
+
       ptr = domains_ptr.read_pointer
       ptr.get_array_of_pointer(0, size).map { |dom_ptr| Libvirt::Domain.new(dom_ptr) }
     end
 
+    def list_all_storage_pools_qty(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Storage.enum_type(:list_all_pools_flags)
+      result = FFI::Storage.virConnectListAllStoragePools(@conn_ptr, nil, flags)
+      raise Errors::LibError, "Couldn't retrieve storage pools qty with flags #{flags.to_s(16)}" if result.negative?
+
+      result
+    end
+
+    def list_all_storage_pools(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Storage.enum_type(:list_all_pools_flags)
+      size = list_all_storage_pools_qty(flags)
+      return [] if size.zero?
+
+      storage_pools_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Storage.virConnectListAllStoragePools(@conn_ptr, storage_pools_ptr, flags)
+      raise Errors::LibError, "Couldn't retrieve storage pools list with flags #{flags.to_s(16)}" if result.negative?
+
+      ptr = storage_pools_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |stp_ptr| StoragePool.new(stp_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}" }
+        @close_data[:block].call(self, reason, @close_data[: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
+      end
+      FFI::Host.virConnectRegisterCloseCallback(@conn_ptr, @close_cb, nil, @close_free_func)
+    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}" }
@@ -112,9 +161,9 @@ module Libvirt
           cb_data.pointer,
           cb_data_free_func
       )
-      if result < 0
+      if result.negative?
         cb_data.pointer.free
-        raise Error, "Couldn't register domain event callback"
+        raise Errors::LibError, "Couldn't register domain event callback"
       end
 
       STORAGE.store_struct(
@@ -131,45 +180,58 @@ module Libvirt
       dbg { "#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
+      raise Errors::LibError, "Couldn't deregister domain event callback" if result.negative?
 
-      STORAGE.remove_struct(connection_pointer: @conn_ptr, callback_id: callback_id)
+      # virConnectDomainEventDeregisterAny will call free func
+      # So we don't need to remove object from STORAGE here.
+      true
     end
 
     def lib_version
       version_ptr = ::FFI::MemoryPointer.new(:ulong)
-      result = FFI::Connection.virConnectGetLibVersion(@conn_ptr, version_ptr)
-      raise Error, "Couldn't get connection lib version" if result < 0
+      result = FFI::Host.virConnectGetLibVersion(@conn_ptr, version_ptr)
+      raise Errors::LibError, "Couldn't get connection lib version" if result.negative?
+
       version_number = version_ptr.get_ulong(0)
-      Libvirt::Util.parse_version(version_number)
+      Util.parse_version(version_number)
     end
 
     def hostname
-      FFI::Connection.virConnectGetHostname(@conn_ptr)
+      FFI::Host.virConnectGetHostname(@conn_ptr)
     end
 
     # @param type [String,NilClass]
     def max_vcpus(type = nil)
-      FFI::Connection.virConnectGetMaxVcpus(@conn_ptr, type)
+      FFI::Host.virConnectGetMaxVcpus(@conn_ptr, type)
     end
 
     def capabilities
-      FFI::Connection.virConnectGetCapabilities(@conn_ptr)
+      FFI::Host.virConnectGetCapabilities(@conn_ptr)
     end
 
     def node_info
-      node_info_ptr = ::FFI::MemoryPointer.new(FFI::NodeInfo::Struct.by_value)
-      result = FFI::NodeInfo.virNodeGetInfo(@conn_ptr, node_info_ptr)
-      raise Error, "Couldn't get connection node info" if result < 0
+      node_info_ptr = ::FFI::MemoryPointer.new(FFI::Host::NodeInfoStruct.by_value)
+      result = FFI::Host.virNodeGetInfo(@conn_ptr, node_info_ptr)
+      raise Errors::LibError, "Couldn't get connection node info" if result.negative?
+
       NodeInfo.new(node_info_ptr)
     end
 
     def stream(flags = 0)
       pointer = FFI::Stream.virStreamNew(@conn_ptr, flags)
-      raise Error, "Couldn't create stream" if pointer.null?
+      raise Errors::LibError, "Couldn't create stream" if pointer.null?
+
       Stream.new(pointer)
     end
 
+    def define_domain(xml, options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Domain.enum_type(:define_flags)
+      pointer = FFI::Domain.virDomainDefineXMLFlags(@conn_ptr, xml, flags)
+      raise Errors::LibError, "Couldn't define domain" if pointer.null?
+
+      Domain.new(pointer)
+    end
+
     private
 
     def set_connection(conn_ptr)
@@ -177,7 +239,7 @@ module Libvirt
     end
 
     def check_open!
-      raise Error, "Connection to #{@uri.inspect} is not open" if @conn_ptr.null?
+      raise Errors::LibError, "Connection to #{@uri.inspect} is not open" if @conn_ptr.null?
     end
 
     def dbg(&block)

data/lib/libvirt/domain.rb

@@ -2,10 +2,10 @@
 
 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
+      raise Errors::LibError, "Couldn't retrieve domain reference" if ref_result.negative?
+
       new(dom_ptr)
     end
 
@@ -13,9 +13,11 @@ module Libvirt
       @dom_ptr = dom_ptr
 
       free = ->(obj_id) do
+        Util.log(:debug) { "Finalize Libvirt::Domain 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
+        warn "Couldn't free Libvirt::Domain (0x#{obj_id.to_s(16)}) pointer #{@dom_ptr.address}" if fr_result.negative?
       end
       ObjectSpace.define_finalizer(self, free)
     end
@@ -24,8 +26,11 @@ module Libvirt
       state = ::FFI::MemoryPointer.new(:int)
       reason = ::FFI::MemoryPointer.new(:int)
       result = FFI::Domain.virDomainGetState(@dom_ptr, state, reason, 0)
-      raise Error, "Couldn't get domain state" if result < 0
-      [state.read_int, reason.read_int]
+      raise Errors::LibError, "Couldn't get domain state" if result.negative?
+
+      state_sym = FFI::Domain.enum_type(:state)[state.read_int]
+      reason_sym = FFI::Domain.state_reason(state_sym, reason.read_int)
+      [state_sym, reason_sym]
     end
 
     def to_ptr
@@ -35,7 +40,8 @@ module Libvirt
     def uuid
       buff = ::FFI::MemoryPointer.new(:char, FFI::Domain::UUID_STRING_BUFLEN)
       result = FFI::Domain.virDomainGetUUIDString(@dom_ptr, buff)
-      raise Error, "Couldn't get domain uuid" if result < 0
+      raise Errors::LibError, "Couldn't get domain uuid" if result.negative?
+
       buff.read_string
     end
 
@@ -71,17 +77,108 @@ module Libvirt
       dbg { "#screenshot stream=#{stream}, display=#{display}," }
 
       mime_type, pointer = FFI::Domain.virDomainScreenshot(@dom_ptr, stream.to_ptr, display, 0)
-      raise Error, "Couldn't attach domain screenshot" if pointer.null?
+      raise Errors::LibError, "Couldn't attach domain screenshot" if pointer.null?
+
       # free pointer required
       mime_type
     end
 
     def free_domain
       result = FFI::Domain.virDomainFree(@dom_ptr)
-      raise Error, "Couldn't free domain" if result < 0
+      raise Errors::LibError, "Couldn't free domain" if result.negative?
+
       @dom_ptr = nil
     end
 
+    def start(flags = 0)
+      result = FFI::Domain.virDomainCreateWithFlags(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't start domain" if result.negative?
+    end
+
+    def reboot(flags = 0)
+      result = FFI::Domain.virDomainReboot(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't reboot domain" if result.negative?
+    end
+
+    def shutdown(flags = :ACPI_POWER_BTN)
+      result = FFI::Domain.virDomainShutdownFlags(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't shutdown domain" if result.negative?
+    end
+
+    def power_off(flags = 0)
+      result = FFI::Domain.virDomainDestroyFlags(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't power off domain" if result.negative?
+    end
+
+    def reset(flags = 0)
+      result = FFI::Domain.virDomainReset(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't reset domain" if result.negative?
+    end
+
+    def suspend
+      result = FFI::Domain.virDomainSuspend(@dom_ptr)
+      raise Errors::LibError, "Couldn't suspend domain" if result.negative?
+    end
+
+    def resume
+      result = FFI::Domain.virDomainResume(@dom_ptr)
+      raise Errors::LibError, "Couldn't resume domain" if result.negative?
+    end
+
+    # Undefine a domain.
+    # If the domain is running, it's converted to transient domain, without stopping it.
+    # If the domain is inactive, the domain configuration is removed.
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @see Libvirt::FFI::Domain enum :undefine_flags_values for acceptable keys
+    # @see Libvirt::Util.parse_flags for possible argument values
+    # @raise [Libvirt::Errors::LibError] if operation failed
+    def undefine(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Domain.enum_type(:undefine_flags_values)
+      result = FFI::Domain.virDomainUndefineFlags(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't resume domain" if result.negative?
+    end
+
+    # After save_memory(:PAUSED) you need to call #start and #resume
+    # to move domain to the running state.
+    def save_memory(flags = :PAUSED)
+      result = FFI::Domain.virDomainManagedSave(@dom_ptr, flags)
+      raise Errors::LibError, "Couldn't save domain memory" if result.negative?
+    end
+
+    # Sets metadata
+    # @param metadata [String] xml node for element type, text for other types
+    #   DESCRIPTION 0x0 - Operate on <description>
+    #   TITLE 0x1 - Operate on <title>
+    #   ELEMENT 0x2 - Operate on <metadata>
+    # @param type [Integer,Symbol] one of :ELEMENT, :TITLE, :DESCRIPTION
+    # @param key [String] xml key (required for type element)
+    # @param uri [String] xml namespace (required for type element)
+    # @param flags [Integer,Symbol] one off AFFECT_CURRENT, AFFECT_CONFIG, AFFECT_LIVE
+    #   AFFECT_CURRENT 0x0 - Affect current domain state.
+    #   AFFECT_LIVE 0x1 - Affect running domain state.
+    #   AFFECT_CONFIG 0x2 - Affect persistent domain state.
+    # @raise [Libvirt::Errors::LibError] if operation failed
+    def set_metadata(metadata, type: :ELEMENT, key: nil, uri: nil, flags: :AFFECT_CURRENT)
+      result = FFI::Domain.virDomainSetMetadata(@dom_ptr, type, metadata, key, uri, flags)
+      raise Errors::LibError, "Couldn't set domain metadata" if result.negative?
+    end
+
+    # Retrieves metadata
+    # @param type [Integer,Symbol] one of :ELEMENT, :TITLE, :DESCRIPTION
+    # @param uri [String] xml namespace (required for type element)
+    # @param flags [Integer,Symbol] one off AFFECT_CURRENT, AFFECT_CONFIG, AFFECT_LIVE
+    #   AFFECT_CURRENT 0x0 - Affect current domain state.
+    #   AFFECT_LIVE 0x1 - Affect running domain state.
+    #   AFFECT_CONFIG 0x2 - Affect persistent domain state.
+    # @raise [Libvirt::Errors::LibError] if operation failed
+    # @return [String] xml node, title, or description.
+    def get_metadata(type: :ELEMENT, uri: nil, flags: :AFFECT_CURRENT)
+      result = FFI::Domain.virDomainGetMetadata(@dom_ptr, type, uri, flags)
+      raise Errors::LibError, "Couldn't get domain metadata" if result.nil?
+
+      result
+    end
+
     private
 
     def dbg(&block)

data/lib/libvirt/domain_callback_storage.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Libvirt
   class DomainCallbackStorage
-
     class CallbackDataStruct < ::FFI::Struct
       layout :connection_pointer, :pointer,
              :callback_id, :int
@@ -14,39 +15,36 @@ module Libvirt
     #   cb_data [Libvirt::DomainCallbackStorage::CallbackDataStruct],
     #   cb_data_free_func [FFI::Function]
     def allocate_struct
-      dbg { "#allocate_struct" }
+      dbg { '#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|
-        dbg { "Libvirt::DomainCallbackStorage cb_data_free_func triggered" }
-        remove_struct(pointer: pointer)
+      cb_data_free_func = FFI::Common.free_function do |pointer|
+        dbg { 'Libvirt::DomainCallbackStorage cb_data_free_func triggered' }
+        remove_struct(pointer)
       end
       [cb_data, cb_data_free_func]
     end
 
     def store_struct(cb_data, connection_pointer:, callback_id:, cb:, opaque:)
-      dbg { "#store_struct" }
+      dbg { '#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)
-      dbg { "#remove_struct pointer=#{pointer}, connection_pointer=#{connection_pointer}, callback_id=#{callback_id}," }
+    def remove_struct(pointer)
+      dbg { "#remove_struct pointer=#{pointer}" }
 
-      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_struct = CallbackDataStruct.new(pointer)
+      connection_pointer = cb_data_struct[:connection_pointer]
+      callback_id = cb_data_struct[:callback_id]
+      dbg { "#remove_struct pointer=#{pointer}, connection_pointer=#{connection_pointer}, callback_id=#{callback_id}," }
 
       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