libvirt_ffi 0.4.1 → 0.5.0

data/lib/libvirt/xml/generic.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Generic
+      class_attribute :_root_path, instance_writer: false, default: '.'
+      class_attribute :_attributes_opts, instance_writer: false, default: {}
+
+      def self.inherited(subclass)
+        subclass._root_path = '.'
+        subclass._attributes_opts = _attributes_opts.dup
+      end
+
+      def self.root_path(path)
+        self._root_path = path
+      end
+
+      def self.attributes(*names)
+        options = names.extract_options!
+        names.each do |name|
+          _attributes_opts.merge!(name.to_sym => options.dup)
+        end
+        attr_accessor(*names)
+      end
+
+      def self.attribute(name, options = {})
+        _attributes_opts.merge!(name.to_sym => options.dup)
+        attr_accessor name
+      end
+
+      # @param xml [String]
+      # @return [Class<LibvirtXml::Generic>]
+      def self.load(xml)
+        xml_node = Nokogiri::XML(xml).xpath(_root_path).first
+        new(xml_node)
+      end
+
+      # Build xml object with attributes.
+      # @param attrs [Hash]
+      # @return [Xml::Base]
+      def self.build(attrs = {})
+        xml_node = Nokogiri::XML(nil)
+        obj = new(xml_node)
+        attrs.each { |key, val| obj.public_send("#{key}=", val) }
+        obj
+      end
+
+      # @param xml_node [Nokogiri::XML::Element]
+      def initialize(xml_node)
+        @xml_node = xml_node
+        parse_xml_node
+      end
+
+      # @param attr [Symbol,String]
+      # @return [Object,nil]
+      def [](attr)
+        read_attribute(attr)
+      end
+
+      # @param attr [Symbol,String]
+      # @param value [Object,nil]
+      # @return [Object,nil]
+      def []=(attr, value)
+        write_attribute(attr, value)
+      end
+
+      # @return [Hash{Symbol=>(Object,nil)}]
+      def to_h
+        _attributes_opts.map do |name, _opts|
+          value = public_send(name)
+          [name, serialize_for_hash(value)]
+        end.to_h
+      end
+
+      # @return [String]
+      def to_xml
+        @xml_node.to_xml
+      end
+
+      delegate :as_json, :to_json, to: :to_h
+
+      private
+
+      def parse_xml_node
+        _attributes_opts.each do |name, opts|
+          value = parse_node(name, opts)
+          value = decode(value, opts)
+          write_attribute name, value
+        end
+      end
+
+      # Parse node value using "parse_node_#{type}" method.
+      # @param name [Symbol]
+      # @param opts [Hash{Symbol=>Object}]
+      # @return [Object, nil]
+      def parse_node(name, opts)
+        type = opts[:type] || :text
+        meth = "parse_node_#{type}"
+
+        if opts[:apply]
+          opts[:apply].call(@xml_node, opts)
+        elsif respond_to?(meth, true)
+          send(meth, name, opts)
+        else
+          raise ArgumentError, "Invalid :type option #{type.inspect} for attribute #{name}"
+        end
+      end
+
+      # Cast value using "decode_#{type}" method.
+      # @param value [String]
+      # @param opts [Hash{Symbol=>Object}]
+      # @return [Object, nil]
+      def decode(value, opts)
+        return if value.nil?
+
+        cast = opts[:cast]
+        return value if cast.nil?
+
+        meth = "decode_#{cast}"
+
+        if opts[:array]
+          value.map do |val|
+            if cast.is_a?(Proc)
+              cast.call(val, opts)
+            elsif respond_to?(meth, true)
+              send(meth, val, opts)
+            else
+              raise ArgumentError, "invalid :cast option #{cast.inspect}"
+            end
+          end
+        end
+
+        if cast.is_a?(Proc)
+          cast.call(value, opts)
+        elsif respond_to?(meth, true)
+          send(meth, value, opts)
+        else
+          raise ArgumentError, "invalid :cast option #{cast.inspect}"
+        end
+      end
+
+      # @param value [String, Boolean]
+      # @return [Boolean]
+      def decode_bool(value, _opts)
+        return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+        return true if value == 'yes'
+
+        return false if value == 'no'
+
+        nil
+      end
+
+      # @param value [String, Integer]
+      # @return [Integer]
+      # @raise [ArgumentError]
+      def decode_int(value, _opts)
+        Integer(value)
+      end
+
+      def find_nodes(name, opts)
+        value_name = opts[:name]&.to_sym || name
+        path = opts[:path] || "./#{value_name}"
+        path == :root ? [@xml_node] : @xml_node.xpath(path)
+      end
+
+      def parse_node_text(name, opts)
+        nodes = find_nodes(name, opts)
+
+        nodes.map(&:text) if opts[:array]
+
+        node = nodes.first
+        return if node.nil?
+
+        node.text
+      end
+
+      def parse_node_attr(name, opts)
+        nodes = find_nodes name, { path: :root }.merge(opts)
+        value_name = opts[:name]&.to_sym || name
+
+        nodes.map { |node| node[value_name.to_s] } if opts[:array]
+
+        node = nodes.first
+        return if node.nil?
+
+        node[value_name.to_s]
+      end
+
+      def parse_node_struct(name, opts)
+        klass = opts[:class]
+        raise ArgumentError, "Invalid :class option nil for attribute #{name}" if klass.nil?
+
+        nodes = find_nodes(name, opts)
+
+        nodes.map { |node| klass.new(node) } if opts[:array]
+
+        node = nodes.first
+        return if node.nil?
+
+        klass.new(node)
+      end
+
+      def parse_node_raw(name, opts)
+        nodes = find_nodes(name, opts)
+
+        nodes.map(&:to_xml) if opts[:array]
+
+        node = nodes.first
+        return if node.nil?
+
+        node.to_xml
+      end
+
+      def parse_node_memory(name, opts)
+        nodes = find_nodes(name, opts)
+
+        if opts[:array]
+          return [] if nodes.empty?
+
+          nodes.map { |node| Util.parse_memory node.text, node['unit'] }
+        end
+
+        node = nodes.first
+        return if node.nil?
+
+        Util.parse_memory node.text, node['unit']
+      end
+
+      def read_attribute(attr)
+        attr = attr.to_sym
+        raise ArgumentError, "can't find attribute #{attr}" unless _attributes_opts.key?(attr)
+
+        instance_variable_get :"@#{attr}"
+      end
+
+      def write_attribute(attr, value)
+        attr = attr.to_sym
+        raise ArgumentError, "can't find attribute #{attr}" unless _attributes_opts.key?(attr)
+
+        instance_variable_set :"@#{attr}", value
+      end
+
+      def serialize_for_hash(value)
+        return value.to_h if value.is_a?(Generic)
+        return value.map { |val| serialize_for_hash(val) } if value.is_a?(Array)
+
+        value
+      end
+    end
+  end
+end

data/lib/libvirt/xml/graphics.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Graphics < Generic
+      # https://libvirt.org/formatdomain.html#elementsGraphics
+
+      attribute :type, type: :attr
+      attribute :listen, type: :attr
+      attribute :port, type: :attr
+      attribute :auto_port, type: :attr, name: :autoport, cast: :bool
+    end
+  end
+end

data/lib/libvirt/xml/max_vcpu.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class MaxVcpu < Generic
+      attribute :value, path: :root, cast: :int
+      attribute :cpu_set, type: :attr, name: :cpuset
+      attribute :current, type: :attr, cast: :int
+      attribute :placement, type: :attr
+    end
+  end
+end

data/lib/libvirt/xml/memory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Memory < Generic
+      attribute :dump_core, type: :attr, name: :dumpCore
+      attribute :slots, type: :attr
+
+      attribute :bytes, apply: ->(node, _opts) do
+        Util.parse_memory node.text, node['unit']
+      end
+    end
+  end
+end

data/lib/libvirt/xml/storage_pool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class StoragePool < Generic
+      # https://libvirt.org/formatstorage.html
+
+      root_path './pool'
+
+      attribute :type, type: :attr
+      attribute :name
+      attribute :uuid
+      attribute :capacity, type: :memory
+      attribute :allocation, type: :memory
+      attribute :available, type: :memory
+      attribute :target_path, path: './target/path'
+      attribute :target_perm_mode, path: './target/permissions/mode'
+      attribute :target_perm_owner, path: './target/permissions/owner'
+      attribute :target_perm_group, path: './target/permissions/group'
+      attribute :target_perm_label, path: './target/permissions/label'
+      # TODO: source
+    end
+  end
+end

data/lib/libvirt/xml/storage_volume.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class StorageVolume < Generic
+      # https://libvirt.org/formatstorage.html
+
+      root_path './volume'
+
+      attribute :type, type: :attr
+      attribute :name
+      attribute :key
+      attribute :allocation, type: :memory
+      attribute :capacity, type: :memory
+      attribute :physical, type: :memory
+      attribute :target_path, path: './target/path'
+      attribute :target_format, type: :attr, name: :type, path: './target/format'
+      attribute :target_perm_mode, path: './target/permissions/mode'
+      attribute :target_perm_owner, path: './target/permissions/owner'
+      attribute :target_perm_group, path: './target/permissions/group'
+      attribute :target_perm_label, path: './target/permissions/label'
+      attribute :timestamp_atime, path: './timestamp/atime'
+      attribute :timestamp_btime, path: './timestamp/btime'
+      attribute :timestamp_ctime, path: './timestamp/ctime'
+      attribute :timestamp_mtime, path: './timestamp/mtime'
+      attribute :compat
+      # TODO: target/encryption target/nocow target/features
+      # todo source
+      # todo backingStore
+    end
+  end
+end

data/lib/libvirt/xml/vcpu.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Vcpu < Generic
+      attribute :id, type: :attr, cast: :int
+      attribute :enabled, type: :attr, cast: :bool
+      attribute :hot_pluggable, type: :attr, cast: :bool, name: :hotpluggable
+      attribute :order, type: :attr, cast: :int
+    end
+  end
+end

data/lib/libvirt/xml.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'libvirt/util'
+
+module Libvirt
+  module Xml
+    # https://libvirt.org/format.html
+    # namespace for libvirt xml objects.
+    # does not loaded by default.
+    # requires nokogiri.
+
+    require 'libvirt/xml/generic'
+    require 'libvirt/xml/storage_pool'
+    require 'libvirt/xml/storage_volume'
+    require 'libvirt/xml/memory'
+    require 'libvirt/xml/graphics'
+    require 'libvirt/xml/disk'
+    require 'libvirt/xml/max_vcpu'
+    require 'libvirt/xml/vcpu'
+    require 'libvirt/xml/domain'
+  end
+end

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

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'libvirt'

data/libvirt.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'lib/libvirt/version'
 
 Gem::Specification.new do |spec|
@@ -17,7 +19,7 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
   spec.bindir        = 'exe'
@@ -25,4 +27,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'ffi', '>= 1.0'
+
+  spec.add_development_dependency 'rubocop', '~> 0.80.1'
 end

data/test_usage/support/libvirt_async.rb

@@ -1,12 +1,10 @@
+# frozen_string_literal: true
+
 module LibvirtAsync
   class << self
-    def logger=(logger)
-      @logger = logger
-    end
+    attr_writer :logger
 
-    def logger
-      @logger
-    end
+    attr_reader :logger
   end
 
   module WithDbg
@@ -26,12 +24,11 @@ module LibvirtAsync
   end
 
   module Util
-    def create_task(parent = nil, reactor = nil, &block)
+    def self.create_task(parent = nil, reactor = nil, &block)
       parent = Async::Task.current? if parent == :current
       reactor ||= Async::Task.current.reactor
       Async::Task.new(reactor, parent, &block)
     end
-    module_function :create_task
   end
 
   class Handle
@@ -77,12 +74,8 @@ module LibvirtAsync
     def register
       dbg { "#{self.class}#register handle_id=#{handle_id}, fd=#{fd}" }
 
-      if (events & Libvirt::EVENT_HANDLE_ERROR) != 0
-        dbg { "#{self.class}#register skip EVENT_HANDLE_ERROR handle_id=#{handle_id}, fd=#{fd}" }
-      end
-      if (events & Libvirt::EVENT_HANDLE_HANGUP) != 0
-        dbg { "#{self.class}#register skip EVENT_HANDLE_HANGUP handle_id=#{handle_id}, fd=#{fd}" }
-      end
+      dbg { "#{self.class}#register skip EVENT_HANDLE_ERROR handle_id=#{handle_id}, fd=#{fd}" } if (events & Libvirt::EVENT_HANDLE_ERROR) != 0
+      dbg { "#{self.class}#register skip EVENT_HANDLE_HANGUP handle_id=#{handle_id}, fd=#{fd}" } if (events & Libvirt::EVENT_HANDLE_HANGUP) != 0
 
       interest = events_to_interest(events)
       dbg { "#{self.class}#register parse handle_id=#{handle_id}, fd=#{fd}, events=#{events}, interest=#{interest}" }
@@ -99,7 +92,7 @@ module LibvirtAsync
         io = IO.new(fd, io_mode, autoclose: false)
         @monitor = Monitor.new(io)
 
-        while @monitor.readiness == nil
+        while @monitor.readiness.nil?
           cancelled = wait_io(interest)
 
           if cancelled
@@ -117,7 +110,6 @@ module LibvirtAsync
 
           dbg { "#{self.class}#register_handle async not ready readiness=#{@monitor.readiness}, handle_id=#{handle_id}, fd=#{fd}" }
         end
-
       end
 
       dbg { "#{self.class}#register_handle invokes fiber=0x#{task.fiber.object_id.to_s(16)} handle_id=#{handle_id}, fd=#{fd}" }
@@ -197,8 +189,6 @@ module LibvirtAsync
         :r
       elsif writable
         :w
-      else
-        nil
       end
     end
 
@@ -223,8 +213,6 @@ module LibvirtAsync
         Libvirt::EVENT_HANDLE_READABLE
       when :w
         Libvirt::EVENT_HANDLE_WRITABLE
-      else
-        nil
       end
     end
   end
@@ -277,14 +265,15 @@ module LibvirtAsync
       dbg { "#{self.class}#initialize timer_id=#{timer_id}, interval=#{interval}" }
 
       @timer_id = timer_id
-      @interval = interval.to_f / 1000.to_f
+      @interval = interval / 1000.0
       @opaque = opaque
       @last_fired = Time.now.to_f
       @monitor = nil
     end
 
     def wait_time
-      return if interval < 0
+      return if interval.negative?
+
       last_fired + interval
     end
 
@@ -358,15 +347,12 @@ module LibvirtAsync
     end
 
     def wait_timer(timeout)
-      begin
-        @monitor.wait(timeout)
-        false
-      rescue Monitor::Cancelled => e
-        dbg { "#{self.class}#wait_timer cancelled #{e.class} #{e.message}" }
-        true
-      end
+      @monitor.wait(timeout)
+      false
+    rescue Monitor::Cancelled => e
+      dbg { "#{self.class}#wait_timer cancelled #{e.class} #{e.message}" }
+      true
     end
-
   end
 
   class Implementations
@@ -396,12 +382,12 @@ module LibvirtAsync
     def print_debug_info
       str = [
           "#{self.class}:0x#{object_id.to_s(16)}",
-          "handles = [",
+          'handles = [',
           @handles.map(&:to_s).join("\n"),
-          "]",
-          "timers = [",
+          ']',
+          'timers = [',
           @timers.map(&:to_s).join("\n"),
-          "]"
+          ']'
       ].join("\n")
       Libvirt.logger&.debug { str }
     end
@@ -432,10 +418,16 @@ module LibvirtAsync
           remove_handle: method(:remove_handle).to_proc,
           add_timer: method(:add_timer).to_proc,
           update_timer: method(:update_timer).to_proc,
-          remove_timer: method(:remove_timer).to_proc
+          remove_timer: method(:remove_timer).to_proc,
+          schedule: method(:schedule).to_proc
       )
     end
 
+    def schedule(&block)
+      task = Async::Task.new(Async::Task.current.reactor, nil, &block)
+      task.reactor << task.fiber
+    end
+
     def add_handle(fd, events, opaque)
       # add a handle to be tracked by this object.  The application is
       # expected to maintain a list of internal handle IDs (integers); this

data/test_usage/support/log_formatter.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 class LogFormatter
-  LOG_FORMAT = "%s, %s [%s/%s/%s] %s\n".freeze
-  DEFAULT_DATETIME_FORMAT = "%F %T.%N".freeze
+  LOG_FORMAT = "%s, %s [%s/%s/%s] %s\n"
+  DEFAULT_DATETIME_FORMAT = '%F %T.%N'
 
   attr_accessor :datetime_format
 
@@ -9,14 +11,7 @@ class LogFormatter
   end
 
   def call(severity, time, progname, message)
-    LOG_FORMAT % [
-        severity[0..0],
-        format_datetime(time),
-        "0x#{Async::Task.current?&.object_id&.to_s(16)}",
-        "0x#{Fiber.current.object_id.to_s(16)}",
-        progname,
-        format_message(message)
-    ]
+    format(LOG_FORMAT, severity[0..0], format_datetime(time), "0x#{Async::Task.current?&.object_id&.to_s(16)}", "0x#{Fiber.current.object_id.to_s(16)}", progname, format_message(message))
   end
 
   private

data/test_usage/test_domain.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'libvirt'
+require 'logger'
+require 'active_support/all'
+require 'async'
+
+require_relative 'support/libvirt_async'
+require_relative 'support/log_formatter'
+
+require 'libvirt/xml'
+
+Libvirt.logger = Logger.new(STDOUT, formatter: LogFormatter.new)
+Libvirt.logger.level = ENV['DEBUG'] ? :debug : :info
+
+IMPL = LibvirtAsync::Implementations.new
+
+Async do
+  ASYNC_REACTOR = Async::Task.current.reactor
+
+  puts "Lib version #{Libvirt.lib_version}"
+  puts "Gem version #{Libvirt::VERSION}"
+
+  IMPL.start
+
+  conn = Libvirt::Connection.new('qemu+tcp://localhost:16510/system')
+  conn.open
+
+  puts "Connection version #{conn.version.inspect}"
+  puts "Connection lib_version #{conn.lib_version.inspect}"
+  puts "Connection hostname #{conn.hostname.inspect}"
+
+  doms = conn.list_all_domains
+  puts "Connection domains qty #{doms.size}"
+
+  doms.each.with_index do |dom, i|
+    puts "Domain #{i} xml", dom.xml_desc
+    puts "Domain #{i} xml object", Libvirt::Xml::Domain.load(dom.xml_desc).to_h
+  end
+
+end