libvirt_ffi 0.4.0 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79ea563057bb675ad519b6dfafca175b69afe8f9b0dc9b3ab76c32175372eab1
-  data.tar.gz: 86420a7e48c60ff3a4cf3bbd5377d8070facd1e453494b16225a78c7c3e4c898
+  metadata.gz: 2a2337cfa3a044b561ab70fe277e7fafff9f39919c494edc64e0f24dabce256d
+  data.tar.gz: a2dbb17ebb8eca45d0336293da344f1b6959f5afdbcee394d87ad5c103a9406a
 SHA512:
-  metadata.gz: e5c81de1008c0a2c55bcacbbd0a50611d492eba8ee7232fb007f861e011f71053e75434563374c60037a89330b10da5f2873b5fd7359a8ba7bd9a88c011da01d
-  data.tar.gz: b803fae7ff7a85fa744784c89e6566acd43bad33f3229af2f97404e852021005084ca7513afea67f28c9e6e0bc9d2309731f25899bb5b9b5fcb2d8568c46c7d3
+  metadata.gz: 3e1354133c74a9fe27affc1414f2e8a466fd1c97664e3ed365736c7f3c574d9e7e1530bd15af5d229442437e33cfcf4f18d48b8e538af7e62a49975d92d7b591
+  data.tar.gz: 57d42fe97ad18a5827710d63eec68d0681ec1282d97168a71f1ce27263cc69c8f0063c4374543bb8baf0ff707a587080f23530b0fbc1d7ce8f158a46f57f62a4

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.rb

@@ -4,19 +4,18 @@ 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/ffi/stream'
+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
@@ -28,10 +27,11 @@ module Libvirt
   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

@@ -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,25 @@ 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 free_memory
+      result = FFI::Host.virNodeGetFreeMemory(@conn_ptr)
+      raise Errors::LibError, "Couldn't set connection keep_alive" if result.negative?
+
+      result
     end
 
     def to_s
@@ -81,22 +96,63 @@ 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)
-      Util.logger.debug { "Libvirt::Connection#register_domain_event_callback event_id=#{event_id}" }
+      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)
@@ -112,9 +168,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(
@@ -128,48 +184,61 @@ module Libvirt
     end
 
     def deregister_domain_event_callback(callback_id)
-      Util.logger.debug { "Libvirt::Connection#deregister_domain_event_callback callback_id=#{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
+      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 +246,11 @@ 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)
+      Util.log(:debug, 'Libvirt::Connection', &block)
     end
   end
 end