libvirt_ffi 0.5.6 → 0.8.0

data/lib/libvirt/ffi/network.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Network
+      # https://libvirt.org/html/libvirt-libvirt-network.html
+
+      extend ::FFI::Library
+      extend Helpers
+      ffi_lib Util.library_path
+
+      EVENT_ID_TO_CALLBACK = {
+          LIFECYCLE: :virConnectNetworkEventLifecycleCallback
+      }.freeze
+
+      ## Enums
+
+      # enum virConnectListAllNetworksFlags
+      enum :list_all_flags, [
+          :INACTIVE, 0x1,
+          :ACTIVE, 0x2,
+          :PERSISTENT, 0x4,
+          :TRANSIENT, 0x8,
+          :AUTOSTART, 0x10,
+          :NO_AUTOSTART, 0x20
+      ]
+
+      # enum virIPAddrType
+      enum :ip_addr_type, [
+          :IPV4, 0x0,
+          :IPV6, 0x1
+      ]
+
+      # enum virNetworkEventID
+      enum :event_id, [
+          :LIFECYCLE, 0x0 # virConnectNetworkEventLifecycleCallback
+      ]
+
+      # enum virNetworkEventLifecycleType
+      enum :event_lifecycle_type, [
+          :DEFINED, 0x0,
+          :UNDEFINED, 0x1,
+          :STARTED, 0x2,
+          :STOPPED, 0x3
+      ]
+
+      # enum virNetworkUpdateCommand
+      enum :update_command, [
+          :NONE, 0x0, # (invalid)
+          :MODIFY, 0x1, # modify an existing element
+          :DELETE, 0x2, # delete an existing element
+          :ADD_LAST, 0x3, # add an element at end of list
+          :ADD_FIRST, 0x4 # add an element at start of list
+      ]
+
+      # enum virNetworkUpdateFlags
+      enum :update_flags, [
+          :AFFECT_CURRENT, 0x0, # affect live if network is active, config if its not active
+          :AFFECT_LIVE, 0x1, # affect live state of network only
+          :AFFECT_CONFIG, 0x2 # affect persistent config only
+      ]
+
+      # enum virNetworkUpdateSection
+      enum :update_section, [
+          :NONE, 0x0, # (invalid)
+          :BRIDGE, 0x1, # <bridge>
+          :DOMAIN, 0x2, # <domain>
+          :IP, 0x3, # <ip>
+          :IP_DHCP_HOST, 0x4, # <ip>/<dhcp>/<host>
+          :IP_DHCP_RANGE, 0x5, # <ip>/<dhcp>/<range>
+          :FORWARD, 0x6, # <forward>
+          :FORWARD_INTERFACE, 0x7, # <forward>/<interface>
+          :FORWARD_PF, 0x8, # <forward>/<pf>
+          :PORTGROUP, 0x9, # <portgroup>
+          :DNS_HOST, 0xa, # <dns>/<host>
+          :DNS_TXT, 0xb, # <dns>/<txt>
+          :DNS_SRV, 0xc # <dns>/<srv>
+      ]
+
+      # enum virNetworkXMLFlags
+      enum :xml_flags, [
+          :INACTIVE, 0x1 # dump inactive network information
+      ]
+
+      ## Structs
+
+      # struct virNetworkDHCPLease {
+      #   char *   iface # Network interface name
+      #   long long   expirytime # Seconds since epoch
+      #   int   type # virIPAddrType
+      #   char *   mac # MAC address
+      #   char *   iaid # IAID
+      #   char *   ipaddr # IP address
+      #   unsigned int   prefix # IP address prefix
+      #   char *   hostname # Hostname
+      #   char *   clientid # Client ID or DUID
+      # }
+      class DhcpLeaseStruct < ::FFI::Struct
+        layout :iface, :string,
+               :expirytime, :long_long,
+               :type, FFI::Network.enum_type(:ip_addr_type),
+               :mac, :string,
+               :iaid, :string,
+               :ipaddr, :string,
+               :prefix, :uint,
+               :hostname, :string,
+               :clientid, :string
+      end
+
+      ## Callbacks
+
+      # typedef virConnectNetworkEventGenericCallback
+      # void  virConnectNetworkEventGenericCallback  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   void * opaque
+      # )
+      callback :virConnectNetworkEventGenericCallback,
+               [:pointer, :pointer, :pointer],
+               :void
+
+      # typedef virConnectNetworkEventLifecycleCallback
+      # void  virConnectNetworkEventLifecycleCallback  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   int event,
+      #   int detail,
+      #   void * opaque
+      # )
+      callback :virConnectNetworkEventLifecycleCallback,
+               [:pointer, :pointer, :event_lifecycle_type, :int, :pointer],
+               :void
+
+      ## Functions
+
+      # int  virConnectListAllNetworks  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr ** nets,
+      #   unsigned int flags
+      # )
+      attach_function :virConnectListAllNetworks,
+                      [:pointer, :pointer, :list_all_flags],
+                      :int
+
+      # int  virConnectListDefinedNetworks  (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListDefinedNetworks,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int  virConnectListNetworks (
+      #   virConnectPtr conn,
+      #   char ** const names,
+      #   int maxnames
+      # )
+      attach_function :virConnectListNetworks,
+                      [:pointer, :pointer, :int],
+                      :int
+
+      # int  virConnectNetworkEventDeregisterAny  (
+      #   virConnectPtr conn,
+      #   int callbackID
+      # )
+      attach_function :virConnectNetworkEventDeregisterAny, [:pointer, :int], :int
+
+      # int  virConnectNetworkEventRegisterAny  (
+      #   virConnectPtr conn,
+      #   virNetworkPtr net,
+      #   int eventID,
+      #   virConnectNetworkEventGenericCallback cb,
+      #   void * opaque,
+      #   virFreeCallback freecb
+      # )
+      attach_function :virConnectNetworkEventRegisterAny,
+                      [:pointer, :pointer, :event_id, :pointer, :pointer, :pointer],
+                      :int
+
+      # int  virConnectNumOfDefinedNetworks (
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectNumOfDefinedNetworks,
+                      [:pointer],
+                      :int
+
+      # int  virConnectNumOfNetworks (
+      #   virConnectPtr conn
+      # )
+      attach_function :virConnectNumOfNetworks,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkCreate (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkCreate,
+                      [:pointer],
+                      :int
+
+      # virNetworkPtr  virNetworkCreateXML  (
+      #   virConnectPtr conn,
+      #   const char * xmlDesc
+      # )
+      attach_function :virNetworkCreateXML,
+                      [:pointer, :string],
+                      :pointer
+
+      # void  virNetworkDHCPLeaseFree (
+      #   virNetworkDHCPLeasePtr lease
+      # )
+      attach_function :virNetworkDHCPLeaseFree,
+                      [:pointer],
+                      :void
+
+      # virNetworkPtr  virNetworkDefineXML  (
+      #   virConnectPtr conn,
+      #   const char * xml
+      # )
+      attach_function :virNetworkDefineXML,
+                      [:pointer, :string],
+                      :pointer
+
+      # int  virNetworkDestroy (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkDestroy,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkFree (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkFree,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkGetAutostart (
+      #   virNetworkPtr network,
+      #   int * autostart
+      # )
+      attach_function :virNetworkGetAutostart,
+                      [:pointer, :pointer],
+                      :int
+
+      # char * virNetworkGetBridgeName (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkGetBridgeName,
+                      [:pointer],
+                      :string
+
+      # virConnectPtr  virNetworkGetConnect (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkGetConnect,
+                      [:pointer],
+                      :pointer
+
+      # int  virNetworkGetDHCPLeases (
+      #   virNetworkPtr network,
+      #   const char * mac,
+      #   virNetworkDHCPLeasePtr ** leases,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkGetDHCPLeases,
+                      [:pointer, :string, :pointer, :uint],
+                      :int
+
+      # const char * virNetworkGetName (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkGetName,
+                      [:pointer],
+                      :string
+
+      # int  virNetworkGetUUID  (
+      #   virNetworkPtr network,
+      #   unsigned char * uuid
+      # )
+      attach_function :virNetworkGetUUID,
+                      [:pointer, :pointer],
+                      :int
+
+      # int  virNetworkGetUUIDString (
+      #   virNetworkPtr network,
+      #   char * buf
+      # )
+      attach_function :virNetworkGetUUIDString,
+                      [:pointer, :pointer],
+                      :int
+
+      # char *  virNetworkGetXMLDesc (
+      #   virNetworkPtr network,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkGetXMLDesc,
+                      [:pointer, :xml_flags],
+                      :string
+
+      # int  virNetworkIsActive (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkIsActive,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkIsPersistent (
+      #   virNetworkPtr net
+      # )
+      attach_function :virNetworkIsPersistent,
+                      [:pointer],
+                      :int
+
+      # virNetworkPtr  virNetworkLookupByName (
+      #   virConnectPtr conn,
+      #   const char * name
+      # )
+      attach_function :virNetworkLookupByName,
+                      [:pointer, :string],
+                      :pointer
+
+      # virNetworkPtr  virNetworkLookupByUUID (
+      #   virConnectPtr conn,
+      #   const unsigned char * uuid
+      # )
+      attach_function :virNetworkLookupByUUID,
+                      [:pointer, :pointer],
+                      :pointer
+
+      # virNetworkPtr  virNetworkLookupByUUIDString (
+      #   virConnectPtr conn,
+      #   const char * uuidstr
+      # )
+      attach_function :virNetworkLookupByUUIDString,
+                      [:pointer, :string],
+                      :pointer
+
+      # int  virNetworkRef (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkRef,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkSetAutostart (
+      #   virNetworkPtr network,
+      #   int autostart
+      # )
+      attach_function :virNetworkSetAutostart,
+                      [:pointer, :int],
+                      :int
+
+      # int  virNetworkUndefine (
+      #   virNetworkPtr network
+      # )
+      attach_function :virNetworkUndefine,
+                      [:pointer],
+                      :int
+
+      # int  virNetworkUpdate (
+      #   virNetworkPtr network,
+      #   unsigned int command,
+      #   unsigned int section,
+      #   int parentIndex,
+      #   const char * xml,
+      #   unsigned int flags
+      # )
+      attach_function :virNetworkUpdate,
+                      [:pointer, :update_command, :update_section, :int, :string, :update_flags],
+                      :int
+
+      ## Helpers
+      module_function
+
+      # Creates event callback function for provided event_id
+      # @param event_id [Integer,Symbol]
+      # @yield connect_ptr, network_ptr, *args, opaque_ptr
+      # @return [FFI::Function]
+      def event_callback_for(event_id, &block)
+        event_id_sym = event_id.is_a?(Symbol) ? event_id : enum_type(:event_id)[event_id]
+
+        callback_name = EVENT_ID_TO_CALLBACK.fetch(event_id_sym)
+        callback_function(callback_name) do |*args|
+          Util.log(:debug, name) { ".event_callback_for #{event_id_sym} CALLBACK #{args.map(&:to_s).join(', ')}," }
+          block.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/libvirt/ffi/storage.rb

@@ -9,6 +9,11 @@ module Libvirt
       extend Helpers
       ffi_lib Util.library_path
 
+      EVENT_ID_TO_CALLBACK = {
+          LIFECYCLE: :virConnectStoragePoolEventLifecycleCallback,
+          REFRESH: :virConnectStoragePoolEventGenericCallback
+      }.freeze
+
       # enum virStoragePoolState
       enum :pool_state, [
           :INACTIVE, 0x0, # Not running
@@ -63,6 +68,23 @@ module Libvirt
           :INACTIVE, 0x1 # dump inactive pool/volume information
       ]
 
+      # enum virStoragePoolEventID
+      enum :event_id, [
+          :LIFECYCLE, 0x0, # virConnectStoragePoolEventLifecycleCallback
+          :REFRESH, 0x1 # virConnectStoragePoolEventGenericCallback
+      ]
+
+      # enum virStoragePoolEventLifecycleType
+      enum :event_lifecycle_type, [
+          :DEFINED, 0x0,
+          :UNDEFINED, 0x1,
+          :STARTED, 0x2,
+          :STOPPED, 0x3,
+          :CREATED, 0x4,
+          :DELETED, 0x5,
+          :LAST, 0x6
+      ]
+
       # struct virStoragePoolInfo {
       #   int   state #   virStoragePoolState flags
       #   unsigned long long   capacity #   Logical size bytes
@@ -87,6 +109,26 @@ module Libvirt
                :allocation, :ulong_long
       end
 
+      # typedef void (*virConnectStoragePoolEventGenericCallback) (
+      #   virConnectPtr conn,
+      #   virStoragePoolPtr pool,
+      #   void * opaque
+      # )
+      callback :virConnectStoragePoolEventGenericCallback,
+               [:pointer, :pointer, :pointer],
+               :void
+
+      # typedef void (*virConnectStoragePoolEventLifecycleCallback) (
+      #   virConnectPtr conn,
+      #   virStoragePoolPtr pool,
+      #   int event,
+      #   int detail,
+      #   void * opaque
+      # )
+      callback :virConnectStoragePoolEventLifecycleCallback,
+               [:pointer, :pointer, :event_lifecycle_type, :int, :pointer],
+               :void
+
       # int  virConnectListAllStoragePools (
       #   virConnectPtr conn,
       #   virStoragePoolPtr ** pools,
@@ -144,6 +186,49 @@ module Libvirt
       #   unsigned int flags
       # )
       attach_function :virStorageVolGetXMLDesc, [:pointer, :xml_flags], :string
+
+      # int  virConnectStoragePoolEventRegisterAny (
+      #   virConnectPtr conn,
+      #   virStoragePoolPtr pool,
+      #   int eventID,
+      #   virConnectStoragePoolEventGenericCallback cb,
+      #   void * opaque,
+      #   virFreeCallback freecb
+      # )
+      attach_function :virConnectStoragePoolEventRegisterAny,
+                      [:pointer, :pointer, :event_id, :pointer, :pointer, FFI::Common::FREE_CALLBACK],
+                      :int
+
+      # int  virConnectStoragePoolEventDeregisterAny (
+      #   virConnectPtr conn,
+      #   int callbackID
+      # )
+      attach_function :virConnectStoragePoolEventDeregisterAny,
+                      [:pointer, :int],
+                      :int
+
+      # int  virStoragePoolGetUUIDString  (virStoragePoolPtr pool,
+      #            char * buf)
+      attach_function :virStoragePoolGetUUIDString, [:pointer, :pointer], :int
+
+      # const char *  virStoragePoolGetName  (virStoragePoolPtr pool)
+      attach_function :virStoragePoolGetName, [:pointer], :string
+
+      module_function
+
+      # Creates event callback function for provided event_id
+      # @param event_id [Integer,Symbol]
+      # @yield connect_ptr, pool_ptr, *args, opaque_ptr
+      # @return [FFI::Function]
+      def event_callback_for(event_id, &block)
+        event_id_sym = event_id.is_a?(Symbol) ? event_id : enum_type(:event_id)[event_id]
+
+        callback_name = EVENT_ID_TO_CALLBACK.fetch(event_id_sym)
+        callback_function(callback_name) do |*args|
+          Util.log(:debug, name) { ".event_callback_for #{event_id_sym} CALLBACK #{args.map(&:to_s).join(', ')}," }
+          block.call(*args)
+        end
+      end
     end
   end
 end