libvirt_ffi 0.6.1 → 0.8.1

data/lib/libvirt/loggable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Loggable
+    # caller[0].match(/`(.*)'/)[1]
+
+    module ClassMethods
+      def dbg(prog_name = nil, &block)
+        return if Libvirt.logger.nil?
+
+        if prog_name.nil?
+          meth = caller[0].match(/`(.*)'/)[1]
+          meth = "<#{meth}>" if meth.include?(' ')
+          prog_name = "#{name}.#{meth}"
+        end
+        Libvirt.logger.debug(prog_name, &block)
+      end
+
+      def err(prog_name = nil, &block)
+        return if Libvirt.logger.nil?
+
+        if prog_name.nil?
+          meth = caller[0].match(/`(.*)'/)[1]
+          meth = "<#{meth}>" if meth.include?(' ')
+          prog_name = "#{name}.#{meth}"
+        end
+        Libvirt.logger.error(prog_name, &block)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      super
+    end
+
+    def dbg(prog_name = nil, &block)
+      return if Libvirt.logger.nil?
+
+      if prog_name.nil?
+        meth = caller[0].match(/`(.*)'/)[1]
+        meth = "<#{meth}>" if meth.include?(' ')
+        prog_name = "#{self.class.name}##{meth}"
+      end
+      Libvirt.logger.debug(prog_name, &block)
+    end
+
+    def err(prog_name = nil, &block)
+      return if Libvirt.logger.nil?
+
+      if prog_name.nil?
+        meth = caller[0].match(/`(.*)'/)[1]
+        meth = "<#{meth}>" if meth.include?(' ')
+        prog_name = "#{self.class.name}##{meth}"
+      end
+      Libvirt.logger.error(prog_name, &block)
+    end
+  end
+end

data/lib/libvirt/network.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class Network
+    # @param pointer [FFI::Pointer]
+    def self.load_ref(pointer)
+      result = FFI::Network.virNetworkRef(pointer)
+      raise Errors::LibError, "Couldn't retrieve network reference" if result.negative?
+
+      new(pointer)
+    end
+
+    # @param pointer [FFI::Pointer]
+    def initialize(pointer)
+      @ptr = pointer
+
+      free = ->(obj_id) do
+        dbg { "Finalize Libvirt::Network object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" }
+        return unless @ptr
+
+        warn "Couldn't free Libvirt::Network object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" if FFI::Network.virNetworkFree(@ptr).negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    # @return [FFI::Pointer]
+    def to_ptr
+      @ptr
+    end
+
+    # @return [String]
+    # @raise [Libvirt::Errors::LibError]
+    def uuid
+      buff = ::FFI::MemoryPointer.new(:char, Util::UUID_STRING_BUFLEN)
+      result = FFI::Network.virNetworkGetUUIDString(@ptr, buff)
+      raise Errors::LibError, "Couldn't get network uuid" if result.negative?
+
+      buff.read_string
+    end
+
+    # @return [String]
+    # @raise [Libvirt::Errors::LibError]
+    def name
+      result = FFI::Network.virNetworkGetName(@ptr)
+      raise Errors::LibError, "Couldn't get network name" if result.nil?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @raise [Libvirt::Errors::LibError]
+    def xml_desc(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Network.enum_type(:xml_flags)
+      result = FFI::Network.virNetworkGetXMLDesc(@ptr, flags)
+      raise Errors::LibError, "Couldn't get network xml_desc" if result.nil?
+
+      result
+    end
+
+    # @return [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def active?
+      result = FFI::Network.virNetworkIsActive(@ptr)
+      raise Errors::LibError, "Couldn't get network is active" if result.nil?
+
+      result == 1
+    end
+
+    # @return [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def persistent?
+      result = FFI::Network.virNetworkIsPersistent(@ptr)
+      raise Errors::LibError, "Couldn't get network is persistent" if result.nil?
+
+      result == 1
+    end
+
+    # @return [String]
+    # @raise [Libvirt::Errors::LibError]
+    def bridge_name
+      result = FFI::Network.virNetworkGetBridgeName(@ptr)
+      raise Errors::LibError, "Couldn't get network bridge_name" if result.nil?
+
+      result
+    end
+
+    # @return [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def auto_start?
+      value = ::FFI::MemoryPointer.new(:int)
+      result = FFI::Network.virNetworkGetAutostart(@ptr, value)
+      raise Errors::LibError, "Couldn't get network auto_start" if result.negative?
+
+      value.read_int == 1
+    end
+
+    # @param value [Boolean]
+    # @raise [Libvirt::Errors::LibError]
+    def set_auto_start(value)
+      value = value ? 1 : 0
+      result = FFI::Network.virNetworkSetAutostart(@ptr, value)
+      raise Errors::LibError, "Couldn't set network auto_start" if result.negative?
+    end
+
+    # @param mac [String]
+    # @return [Integer]
+    # @raise [Libvirt::Errors::LibError]
+    def dhcp_leases_qty(mac = nil)
+      result = FFI::Network.virNetworkGetDHCPLeases(@ptr, mac, nil, 0)
+      raise Errors::LibError, "Couldn't get network dhcp leases qty" if result.nil?
+
+      result
+    end
+
+    # @param mac [String]
+    # @return [Array<Libvirt::NetworkDhcpLease>, Array]
+    # @raise [Libvirt::Errors::LibError]
+    def dhcp_leases(mac = nil)
+      size = dhcp_leases_qty(mac)
+      return [] if size.zero?
+
+      dhcp_leases_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Network.virNetworkGetDHCPLeases(@ptr, mac, dhcp_leases_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve network dhcp leases" if result.negative?
+
+      ptr = dhcp_leases_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |dhcpl_ptr| NetworkDhcpLease.new(dhcpl_ptr) }
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def start
+      result = FFI::Network.virNetworkCreate(@ptr)
+      raise Errors::LibError, "Couldn't start network" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def destroy
+      result = FFI::Network.virNetworkDestroy(@ptr)
+      raise Errors::LibError, "Couldn't destroy network" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def undefine
+      result = FFI::Network.virNetworkUndefine(@ptr)
+      raise Errors::LibError, "Couldn't undefine network" if result.negative?
+    end
+
+    # @param xml [String]
+    # @param command [Integer, Symbol]
+    # @param section [Integer, Symbol]
+    # @param flags [Integer, Symbol]
+    # @param parent_index [Integer] default -1 (means don't care)
+    # @raise [Libvirt::Errors::LibError]
+    def update(xml, command, section, flags, parent_index = -1)
+      command = Util.parse_flags command, FFI::Network.enum_type(:update_command)
+      section = Util.parse_flags section, FFI::Network.enum_type(:update_section)
+      flags = Util.parse_flags flags, FFI::Network.enum_type(:update_flags)
+
+      result = FFI::Network.virNetworkUpdate(
+          @ptr,
+          command,
+          section,
+          parent_index,
+          xml,
+          flags
+      )
+      raise Errors::LibError, "Couldn't update network" if result.negative?
+    end
+
+    private
+
+    def dbg(&block)
+      Util.log(:debug, 'Libvirt::Network', &block)
+    end
+  end
+end

data/lib/libvirt/network_dhcp_lease.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class NetworkDhcpLease < BaseInfo
+    struct_class FFI::Network::DhcpLeaseStruct
+
+    # @param pointer [FFI::Pointer]
+    def initialize(pointer)
+      super
+
+      free = ->(obj_id) do
+        dbg { "Finalize Libvirt::NetworkDhcpLease object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" }
+        return unless @ptr
+
+        warn "Couldn't free Libvirt::NetworkDhcpLease object_id=0x#{obj_id.to_s(16)}, pointer=0x#{@ptr.address.to_s(16)}" if FFI::Storage.virNetworkDHCPLeaseFree(@ptr).negative?
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+  end
+end

data/lib/libvirt/storage_pool.rb

@@ -13,7 +13,7 @@ module Libvirt
       @ptr = pointer
 
       free = ->(obj_id) do
-        Util.log(:debug) { "Finalize Libvirt::StoragePool 0x#{obj_id.to_s(16)} @ptr=#{@ptr}," }
+        dbg { "Finalize Libvirt::StoragePool 0x#{obj_id.to_s(16)} @ptr=#{@ptr}," }
         return unless @ptr
 
         fr_result = FFI::Storage.virStoragePoolFree(@ptr)
@@ -79,7 +79,7 @@ module Libvirt
     private
 
     def dbg(&block)
-      Util.log(:debug, 'Libvirt::Domain', &block)
+      Util.log(:debug, 'Libvirt::StoragePool', &block)
     end
   end
 end

data/lib/libvirt/util.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
+require 'objspace'
+
 module Libvirt
   module Util
+    extend Loggable::ClassMethods
+
     UNIT_TO_BYTES = {
         b: 1,
         bytes: 1,
@@ -21,83 +25,102 @@ module Libvirt
 
     UUID_STRING_BUFLEN = 0x80 # RFC4122
 
-    class << self
-      attr_writer :logger
-
-      attr_reader :logger
+    module_function
 
-      def log(severity, prog = nil, &block)
-        return if @logger.nil?
+    def logger
+      @logger if defined?(@logger)
+    end
 
-        @logger.public_send(severity, prog, &block)
-      end
+    def logger=(value)
+      @logger = value
+    end
 
-      def library_path
-        %w[libvirt libvirt.so.0]
-      end
+    def log(severity, prog = nil, &block)
+      return if logger.nil?
 
-      # @param [Integer] version_number ulong
-      def parse_version(version_number)
-        major = version_number / 1_000_000
-        minor = (version_number - major * 1_000_000) / 1_000
-        release = version_number - major * 1_000_000 - minor * 1_000
-        "#{major}.#{minor}.#{release}"
-      end
+      logger.public_send(severity, prog, &block)
+    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)
+    def library_path
+      %w[libvirt libvirt.so.0]
+    end
 
-          return [enum.find(value), value]
-        end
+    # @param [Integer] version_number ulong
+    def parse_version(version_number)
+      major = version_number / 1_000_000
+      minor = (version_number - major * 1_000_000) / 1_000
+      release = version_number - major * 1_000_000 - minor * 1_000
+      "#{major}.#{minor}.#{release}"
+    end
 
-        raise ArgumentError, 'invalid enum value' unless enum.symbol_map.values.include?(value)
+    # @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)
 
-        [value, enum.symbol_map[value]]
+        return [enum.find(value), value]
       end
 
-      # Bitwise OR integer flags calculation for C language.
-      # @param flags [Integer,Symbol,Array<Symbol>,Hash{Symbol=>Boolean},nil]
-      # @param enum [FFI::Enum]
-      # @param default [Integer] optional (default 0x0)
-      # @return [Integer] bitwise OR of keys
-      #  @example Usage:
-      #    parse_flags(nil, enum)
-      #    parse_flags({MANAGED_SAVE: true, SNAPSHOTS_METADATA: true, NVRAM: false}, enum)
-      #    parse_flags({managed_save: true, snapshots_metadata: true, keep_nvram: nil}, enum)
-      #    parse_flags(3, enum)
-      #    parse_flags([:MANAGED_SAVE, :SNAPSHOTS_METADATA], enum)
-      #    parse_flags([:managed_save, :snapshots_metadata], enum)
-      #
-      def parse_flags(flags, enum, default: 0x0)
-        flags = default if flags.nil?
-        flags = enum[flags] if flags.is_a?(Symbol)
-        return flags if flags.is_a?(Integer)
-
-        result = 0x0
-        flags = flags.select { |_, v| v }.keys if flags.is_a?(Hash)
-
-        raise ArgumentError, 'flags must be an Integer or a Hash or an Array' unless flags.is_a?(Array)
-
-        flags.each do |key|
-          result |= enum[key.to_s.upcase.to_sym]
-        end
-
-        result
+      raise ArgumentError, 'invalid enum value' unless enum.symbol_map.values.include?(value)
+
+      [value, enum.symbol_map[value]]
+    end
+
+    # Bitwise OR integer flags calculation for C language.
+    # @param flags [Integer,Symbol,Array<Symbol>,Hash{Symbol=>Boolean},nil]
+    # @param enum [FFI::Enum]
+    # @param default [Integer] optional (default 0x0)
+    # @return [Integer] bitwise OR of keys
+    #  @example Usage:
+    #    parse_flags(nil, enum)
+    #    parse_flags({MANAGED_SAVE: true, SNAPSHOTS_METADATA: true, NVRAM: false}, enum)
+    #    parse_flags({managed_save: true, snapshots_metadata: true, keep_nvram: nil}, enum)
+    #    parse_flags(3, enum)
+    #    parse_flags([:MANAGED_SAVE, :SNAPSHOTS_METADATA], enum)
+    #    parse_flags([:managed_save, :snapshots_metadata], enum)
+    #
+    def parse_flags(flags, enum, default: 0x0)
+      flags = default if flags.nil?
+      flags = enum[flags] if flags.is_a?(Symbol)
+      return flags if flags.is_a?(Integer)
+
+      result = 0x0
+      flags = flags.select { |_, v| v }.keys if flags.is_a?(Hash)
+
+      raise ArgumentError, 'flags must be an Integer or a Hash or an Array' unless flags.is_a?(Array)
+
+      flags.each do |key|
+        result |= enum[key.to_s.upcase.to_sym]
       end
 
-      # @param value [Integer,String]
-      # @param unit [String,Symbol] default 'bytes'
-      # @return [Integer] memory in bytes
-      def parse_memory(value, unit)
-        unit ||= 'bytes'
-        multiplier = UNIT_TO_BYTES.fetch(unit.to_sym)
-        Integer(value) * multiplier
+      result
+    end
+
+    # @param value [Integer,String]
+    # @param unit [String,Symbol] default 'bytes'
+    # @return [Integer] memory in bytes
+    def parse_memory(value, unit)
+      unit ||= 'bytes'
+      multiplier = UNIT_TO_BYTES.fetch(unit.to_sym)
+      Integer(value) * multiplier
+    end
+
+    def define_finalizer(object, &block)
+      free = ->(obj_id) do
+        obj_id_hex = "0x#{obj_id.to_s(16)}"
+        ptr = object.to_ptr
+        ptr_hex = "0x#{ptr.address.to_s(16)}"
+        klass = object.class
+        dbg { "Finalize #{klass} object_id=#{obj_id_hex}, pointer=#{ptr_hex}" }
+        return if ptr.null?
+
+        cl_result = block.call(ptr)
+        err { "Couldn't close #{klass} object_id=#{obj_id_hex}, pointer=#{ptr_hex}" } if cl_result.negative?
       end
+      ObjectSpace.define_finalizer(object, free)
     end
   end
 end

data/lib/libvirt/version.rb

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

data/lib/libvirt/xml/generic.rb

@@ -3,6 +3,9 @@
 module Libvirt
   module Xml
     class Generic
+      TRUE_VALUES = %w[yes on].freeze
+      FALSE_VALUES = %w[no off].freeze
+
       class_attribute :_root_path, instance_writer: false, default: '.'
       class_attribute :_attributes_opts, instance_writer: false, default: {}
 
@@ -23,7 +26,7 @@ module Libvirt
         attr_accessor(*names)
       end
 
-      def self.attribute(name, options = {})
+      def self.attribute(name, **options)
         _attributes_opts.merge!(name.to_sym => options.dup)
         attr_accessor name
       end
@@ -38,7 +41,7 @@ module Libvirt
       # Build xml object with attributes.
       # @param attrs [Hash]
       # @return [Xml::Base]
-      def self.build(attrs = {})
+      def self.build(**attrs)
         xml_node = Nokogiri::XML(nil)
         obj = new(xml_node)
         attrs.each { |key, val| obj.public_send("#{key}=", val) }
@@ -111,7 +114,7 @@ module Libvirt
       # @param opts [Hash{Symbol=>Object}]
       # @return [Object, nil]
       def decode(value, opts)
-        return if value.nil?
+        return opts[:default] if value.nil?
 
         cast = opts[:cast]
         return value if cast.nil?
@@ -144,9 +147,9 @@ module Libvirt
       def decode_bool(value, _opts)
         return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
 
-        return true if value == 'yes'
+        return true if TRUE_VALUES.include?(value)
 
-        return false if value == 'no'
+        return false if FALSE_VALUES.include?(value)
 
         nil
       end

data/lib/libvirt/xml/interface.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Interface < Generic
+      # no official doc found
+      #
+      # <interface type='ethernet' name='lo'>
+      #   <protocol family='ipv4'>
+      #     <ip address='127.0.0.1' prefix='8'/>
+      #   </protocol>
+      #   <protocol family='ipv6'>
+      #     <ip address='::1' prefix='128'/>
+      #   </protocol>
+      #   <link state='unknown'/>
+      # </interface>
+      #
+      # <interface type='bridge'>
+      #   <mac address='52:54:00:4f:7e:b2'/>
+      #   <source bridge='vbr107'/>
+      #   <target dev='vnet4'/>
+      #   <model type='virtio'/>
+      #   <alias name='net0'/>
+      #   <address type='pci' domain='0x0000' bus='0x00' slot='0x03' function='0x0'/>
+      # </interface>
+
+      root_path './interface'
+
+      attribute :type, type: :attr
+
+      attribute :name, type: :attr
+      attribute :link_state, type: :attr, path: './link', name: 'state'
+      attribute :ip_addresses, type: :ip_addresses
+
+      attribute :mac_address, type: :attr, path: './mac', name: 'address'
+      attribute :source_bridge, type: :attr, path: './source', name: 'bridge'
+      attribute :target_dev, type: :attr, path: './target', name: 'dev'
+      attribute :model_type, type: :attr, path: './model', name: 'type'
+      attribute :alias_names, type: :attr, path: './alias', name: 'name', array: true
+      attribute :addresses, type: :addresses
+
+      private
+
+      def parse_node_addresses(_, _opts)
+        nodes = find_nodes(nil, path: './address')
+
+        nodes.map do |node|
+          {
+              type: node['type'],
+              domain: node['domain'],
+              bus: node['bus'],
+              slot: node['slot'],
+              function: node['function']
+          }
+        end
+      end
+
+      def parse_node_ip_addresses(_, _opts)
+        protocols = find_nodes(nil, path: './protocol')
+        ip_addresses = []
+
+        protocols.each do |protocol|
+          family = protocol['family']
+
+          protocol.xpath('./ip').each do |ip|
+            # ip['netmask'], ip['localPtr']
+            ip_addresses.push(
+                address: ip['address'],
+                prefix: ip['prefix'],
+                family: family
+            )
+          end
+        end
+
+        ip_addresses
+      end
+    end
+  end
+end

data/lib/libvirt/xml/ip_address.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class IpAddress < Generic
+      # https://libvirt.org/formatnetwork.html#elementsAddress
+
+      # <ip address="192.168.122.1" netmask="255.255.255.0" localPtr="yes">
+      #   <dhcp>
+      #     <range start="192.168.122.100" end="192.168.122.254"/>
+      #     <host mac="00:16:3e:77:e2:ed" name="foo.example.com" ip="192.168.122.10"/>
+      #     <host mac="00:16:3e:3e:a9:1a" name="bar.example.com" ip="192.168.122.11"/>
+      #   </dhcp>
+      # </ip>
+      # <ip family="ipv6" address="2001:db8:ca2:2::1" prefix="64" localPtr="yes"/>
+      attribute :address, type: :attr
+      attribute :netmask, type: :attr
+      attribute :prefix, type: :attr
+      attribute :local_ptr, type: :attr, name: 'localPtr', cast: :bool, default: false
+      attribute :family, type: :attr, default: 'ipv4'
+      attribute :tftp_root, type: :attr, path: './tftp', name: 'root'
+      attribute :dhcp_ranges, type: :dhcp_ranges
+      attribute :dhcp_hosts, type: :dhcp_hosts
+      attribute :dhcp_bootp_file, type: :attr, path: './dhcp/bootp', name: 'file'
+      attribute :dhcp_bootp_server, type: :attr, path: './dhcp/bootp', name: 'server'
+
+      private
+
+      def parse_node_dhcp_ranges(_, _opts)
+        nodes = find_nodes(nil, path: './dhcp/range')
+
+        nodes.map do |node|
+          [node['start'], node['end']]
+        end
+      end
+
+      def parse_node_dhcp_hosts(_, _opts)
+        nodes = find_nodes(nil, path: './dhcp/host')
+
+        nodes.map do |node|
+          {
+              mac: node['mac'],
+              ip: node['ip'],
+              name: node['name'],
+              host: node['host']
+          }
+        end
+      end
+    end
+  end
+end