libvirt_ffi 0.7.0 → 0.8.0

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

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

data/lib/libvirt/xml.rb

@@ -13,6 +13,9 @@ module Libvirt
     require 'libvirt/xml/generic'
     require 'libvirt/xml/storage_pool'
     require 'libvirt/xml/storage_volume'
+    require 'libvirt/xml/interface'
+    require 'libvirt/xml/ip_address'
+    require 'libvirt/xml/network'
     require 'libvirt/xml/memory'
     require 'libvirt/xml/graphics'
     require 'libvirt/xml/disk'

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: {}
 
@@ -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

data/lib/libvirt/xml/network.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module Xml
+    class Network < Generic
+      # https://libvirt.org/formatnetwork.html
+
+      root_path './network'
+
+      # <network ipv6='yes' trustGuestRxFilters='no'>
+      #   ...
+      attribute :ipv6, type: :attr, cast: :bool, default: false
+
+      attribute :trust_guest_rx_filters,
+                type: :attr,
+                name: 'trustGuestRxFilters',
+                cast: :bool,
+                default: false
+
+      # <name>default</name>
+      # <uuid>3e3fce45-4f53-4fa7-bb32-11f34168b82b</uuid>
+      attribute :name
+      attribute :uuid
+
+      # <metadata>
+      #   <app1:foo xmlns:app1="http://app1.org/app1/">..</app1:foo>
+      #   <app2:bar xmlns:app2="http://app1.org/app2/">..</app2:bar>
+      # </metadata>
+      attribute :metadata, type: :raw
+
+      # <bridge name="virbr0" stp="on" delay="5" macTableManager="libvirt"/>
+      attribute :bridge_name,
+                type: :attr,
+                name: 'name',
+                path: './bridge'
+
+      attribute :bridge_stp,
+                type: :attr,
+                name: 'stp',
+                cast: :bool,
+                path: './bridge'
+
+      attribute :bridge_delay,
+                type: :attr,
+                name: 'delay',
+                cast: :int,
+                path: './bridge'
+
+      attribute :bridge_mac_table_manager,
+                type: :attr,
+                name: 'macTableManager',
+                path: './bridge'
+
+      # <mtu size="9000"/>
+      attribute :mtu_size, type: :attr, path: './mtu', name: 'size', cast: :int
+
+      # <domain name="example.com" localOnly="no"/>
+      attribute :domain_name, type: :attr, path: './domain', name: 'name'
+      attribute :domain_local_only, type: :attr, path: './domain', name: 'localOnly', cast: :bool
+
+      # <forward mode='nat' dev='eth0'>
+      #     <nat>
+      #       <address start='1.2.3.4' end='1.2.3.10'/>
+      #     </nat>
+      #   </forward>
+      attribute :forward_mode, type: :attr, path: './forward', name: 'mode'
+      attribute :forward_dev, type: :attr, path: './forward', name: 'dev'
+      attribute :forward_nat_address, type: :forward_nat, node_name: :address
+      attribute :forward_nat_port, type: :forward_nat, node_name: :port
+
+      # <forward mode='passthrough'>
+      #   <interface dev='eth10'/>
+      #   <interface dev='eth11'/>
+      #   <interface dev='eth12'/>
+      #   <interface dev='eth13'/>
+      #   <interface dev='eth14'/>
+      # </forward>
+      attribute :forward_interfaces,
+                type: :attr,
+                path: './forward/interface',
+                name: 'dev',
+                array: true
+
+      # <forward mode='passthrough'>
+      #   <pf dev='eth0'/>
+      # </forward>
+      attribute :forward_pf,
+                type: :attr,
+                path: './forward/pf',
+                name: 'dev',
+                array: true
+
+      # <forward mode='hostdev' managed='yes'>
+      #     <driver name='vfio'/>
+      #     <address type='pci' domain='0' bus='4' slot='0' function='1'/>
+      #     <address type='pci' domain='0' bus='4' slot='0' function='2'/>
+      #     <address type='pci' domain='0' bus='4' slot='0' function='3'/>
+      #   </forward>
+      attribute :forward_manager,
+                type: :attr,
+                path: './forward',
+                name: 'managed',
+                cast: :bool,
+                default: false
+
+      attribute :forward_driver,
+                type: :attr,
+                path: './forward/driver',
+                name: 'name'
+
+      attribute :forward_addresses, type: :forward_hostdev_address
+
+      attribute :mac_address,
+                type: :attr,
+                path: './mac',
+                name: 'address'
+
+      # <dns>
+      #   <txt name="example" value="example value"/>
+      #   <forwarder addr="8.8.8.8"/>
+      #   <forwarder domain='example.com' addr="8.8.4.4"/>
+      #   <forwarder domain='www.example.com'/>
+      #   <srv service='name' protocol='tcp' domain='test-domain-name' target='.'
+      #     port='1024' priority='10' weight='10'/>
+      #   <host ip='192.168.122.2'>
+      #     <hostname>myhost</hostname>
+      #     <hostname>myhostalias</hostname>
+      #   </host>
+      # </dns>
+      attribute :dns_forwarder, type: :dns_forwarder
+      attribute :dns_txt, type: :dns_txt
+      attribute :dns_host_ip, type: :attr, path: './dns/host', name: 'ip'
+      attribute :dns_hostnames, path: './dns/host/hostname', array: true
+      attribute :dns_srv, type: :dns_txt
+
+      attribute :ip_addresses, type: :struct, path: './ip', class: IpAddress, array: true
+
+      # https://libvirt.org/formatnetwork.html#elementQoS
+      # TODO continue from <bandwidth>
+
+      private
+
+      def parse_node_forward_nat(_, opts)
+        nodes = find_nodes(nil, path: "./forward/nat/#{opts[:node_name]}")
+
+        nodes.map do |node|
+          [node['start'], node['stop']]
+        end
+      end
+
+      def parse_node_forward_hostdev_address(_, _opts)
+        nodes = find_nodes(nil, path: './forward/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_dns_forwarder(_, _opts)
+        nodes = find_nodes(nil, path: './dns/forwarder')
+
+        nodes.map do |node|
+          {
+              domain: node['domain'],
+              addr: node['addr']
+          }
+        end
+      end
+
+      def parse_node_dns_txt(_, _opts)
+        nodes = find_nodes(nil, path: './dns/txt')
+
+        nodes.map do |node|
+          {
+              name: node['name'],
+              value: node['value']
+          }
+        end
+      end
+
+      def parse_node_dns_srv(_, _opts)
+        nodes = find_nodes(nil, path: './dns/srv')
+
+        nodes.map do |node|
+          {
+              name: node['name'],
+              protocol: node['protocol'],
+              target: node['target'],
+              port: node['port'],
+              priority: node['priority'],
+              weight: node['weight'],
+              domain: node['domain']
+          }
+        end
+      end
+    end
+  end
+end