libvirt_ffi 0.2.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 556422a513288d81aa723c2751129033da2118eb1d8a6a03c01e60efa57017fd
-  data.tar.gz: 309fd55853169a8b25669736be80d1b0eebc7f66bb4e082f00714d4e751c9ff7
+  metadata.gz: 2685f9b26b91cc3365a0552374160ab1448e96b122a65f2e2350bf11811230d7
+  data.tar.gz: b89251ca7af3dac7275384f59bd2b93ce93bd7473c1c15ab3302ddad2a021212
 SHA512:
-  metadata.gz: '039e73eb32c5354f99e3c31ca9fab1e81e23b0249bfd20f7ed78c10a9b21da5f2f5b73e124df4c2765b18c8e965e55ee5422135d73f56b84b1465506281c3d0b'
-  data.tar.gz: f9d398150d78a71ed3682a6556cbcbd5e61e9d9304bc38fbaa0935f85798a571fcb9885feed73c50f64e20f7fde06bb79aa120ae7928b183531ac08bc656e4f4
+  metadata.gz: 791f213bfff0092f762ba0e87f3cf1eacb319f8b4530854f9d6bf20dab76b29a47eedb6f582d2c1f9fb8ff94a6f4c26226d3c2f170cb03a173fe16f33d73bb5b
+  data.tar.gz: 803d55a39f54fc9ab52affb71dad317957626614c3f9fc6edbbfce9ecaef038be74de52a011a6d79b501a6cc177f85c874cedb0339fa23fd61eec28e5a7b6d67

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,13 +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 '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.rb

@@ -2,18 +2,20 @@
 
 require 'ffi'
 require 'objspace'
+require 'libvirt/domain_callback_storage'
 require 'libvirt/util'
-require 'libvirt/error'
-require 'libvirt/ffi/common'
-require 'libvirt/ffi/libvirt'
-require 'libvirt/ffi/connection'
-require 'libvirt/ffi/domain'
-require 'libvirt/ffi/event'
-require 'libvirt/ffi/node_info'
+require 'libvirt/errors'
+require 'libvirt/ffi'
+require 'libvirt/base_info'
+require 'libvirt/node_info'
+require 'libvirt/storage_pool_info'
+require 'libvirt/storage_volume_info'
 require 'libvirt/event'
 require 'libvirt/connection'
 require 'libvirt/domain'
-require 'libvirt/node_info'
+require 'libvirt/stream'
+require 'libvirt/storage_pool'
+require 'libvirt/storage_volume'
 require 'libvirt/version'
 
 module Libvirt
@@ -22,15 +24,14 @@ 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)
-      code = FFI::Libvirt.virGetVersion(version_ptr, nil, nil)
-      raise Error, 'failed to get version' if code < 0
+      code = FFI::Host.virGetVersion(version_ptr, nil, nil)
+      raise Errors::LibError, 'failed to get version' if code.negative?
+
       version_number = version_ptr.get_ulong(0)
-      Libvirt::Util.parse_version(version_number)
+      Util.parse_version(version_number)
     end
 
     def logger

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

@@ -2,18 +2,54 @@
 
 module Libvirt
   class Connection
+    DOMAIN_EVENT_IDS = FFI::Domain.enum_type(:event_id).symbols.dup.freeze
+
+    STORAGE = DomainCallbackStorage.new
+
+    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
+      [event_id_sym, func]
+    end.to_h.freeze
+
+    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?
+
+      new(nil).tap { |r| r.send(:set_connection, conn_ptr) }
+    end
+
     def initialize(uri)
       @uri = uri
       @conn_ptr = ::FFI::Pointer.new(0)
-      @cb_data = {}
-      ObjectSpace.define_finalizer(self, proc { |obj_id|
-        STDOUT.puts("finalized Libvirt::Connection #{obj_id.to_s(16)}")
-      })
+      @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::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 connect 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::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
 
@@ -29,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
@@ -51,90 +89,161 @@ 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, self) }
+      ptr.get_array_of_pointer(0, size).map { |dom_ptr| Libvirt::Domain.new(dom_ptr) }
     end
 
-    # @yield conn, dom
-    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}"
+    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}" }
+
+      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.negative?
+        cb_data.pointer.free
+        raise Errors::LibError, "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)
+      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
-      true
-    end
+      raise Errors::LibError, "Couldn't deregister domain event callback" if result.negative?
 
-    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)
+      # 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)
-      # version_number = FFI::Connection.virConnectGetLibVersion(@conn_ptr)
-      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 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)
+      @conn_ptr = conn_ptr
+    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)
+      Util.log(:debug, 'Libvirt::Connection', &block)
     end
   end
 end