libvirt_ffi 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 556422a513288d81aa723c2751129033da2118eb1d8a6a03c01e60efa57017fd
-  data.tar.gz: 309fd55853169a8b25669736be80d1b0eebc7f66bb4e082f00714d4e751c9ff7
+  metadata.gz: 32cd6d96cd065507a105cffe398c5d6bfa2afd2cd472888f831dd2ad382a48de
+  data.tar.gz: 06ae43ce6d0d65c8d6a5daa0914df5cfa01a3102f467bc7bef3bafaa19e2208a
 SHA512:
-  metadata.gz: '039e73eb32c5354f99e3c31ca9fab1e81e23b0249bfd20f7ed78c10a9b21da5f2f5b73e124df4c2765b18c8e965e55ee5422135d73f56b84b1465506281c3d0b'
-  data.tar.gz: f9d398150d78a71ed3682a6556cbcbd5e61e9d9304bc38fbaa0935f85798a571fcb9885feed73c50f64e20f7fde06bb79aa120ae7928b183531ac08bc656e4f4
+  metadata.gz: 205e7bc1253381af45bcf354b784476acf35f862ba212f6a9b7cdeba3673ed2ae5b73b54ec0a894632e753dd8f1e7ba90cec6a40187c1a0c33df6900f4208c71
+  data.tar.gz: d5754a19f39a9c508722b1cb8d29227d38c62eb1c9f0a7503d94aba33f815180217d4b346c32a1e4638a8b1e2526910ebf6dc6ccffe6ab8e3c415870b629b430

data/lib/libvirt/connection.rb

@@ -6,9 +6,11 @@ module Libvirt
       @uri = uri
       @conn_ptr = ::FFI::Pointer.new(0)
       @cb_data = {}
-      ObjectSpace.define_finalizer(self, proc { |obj_id|
-        STDOUT.puts("finalized Libvirt::Connection #{obj_id.to_s(16)}")
-      })
+
+      free = ->(obj_id) do
+        STDOUT.puts("finalized Libvirt::Connection obj_id=0x#{obj_id.to_s(16)}, @conn_ptr=#{@conn_ptr}, @uri=#{@uri}, @cb_data=#{@cb_data}")
+      end
+      ObjectSpace.define_finalizer(self, free)
     end
 
     def open
@@ -61,7 +63,7 @@ module Libvirt
       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
       ptr = domains_ptr.read_pointer
-      ptr.get_array_of_pointer(0, size).map { |dom_ptr| Libvirt::Domain.new(dom_ptr, self) }
+      ptr.get_array_of_pointer(0, size).map { |dom_ptr| Libvirt::Domain.new(dom_ptr) }
     end
 
     # @yield conn, dom
@@ -131,6 +133,12 @@ module Libvirt
       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?
+      Stream.new(pointer)
+    end
+
     private
 
     def check_open!

data/lib/libvirt/domain.rb

@@ -2,12 +2,13 @@
 
 module Libvirt
   class Domain
-    def initialize(dom_ptr, conn)
+    def initialize(dom_ptr)
       @dom_ptr = dom_ptr
-      @conn = conn
-      ObjectSpace.define_finalizer(self, proc { |obj_id|
-        STDOUT.puts("finalized Libvirt::Domain #{obj_id.to_s(16)}")
-      })
+
+      free = ->(obj_id) do
+        STDOUT.puts("finalized Libvirt::Domain obj_id=0x#{obj_id.to_s(16)}, @dom_ptr=#{@dom_ptr},")
+      end
+      ObjectSpace.define_finalizer(self, free)
     end
 
     def get_state
@@ -56,5 +57,12 @@ module Libvirt
     def xml_desc(flags = 0)
       FFI::Domain.virDomainGetXMLDesc(@dom_ptr, flags)
     end
+
+    def screenshot(stream, display = 0)
+      mime_type, pointer = FFI::Domain.virDomainScreenshot(@dom_ptr, stream.to_ptr, display, 0)
+      raise Error, "Couldn't attach domain screenshot" if pointer.null?
+      # free pointer required
+      mime_type
+    end
   end
 end

data/lib/libvirt/event.rb

@@ -9,24 +9,32 @@ module Libvirt
     extend Forwardable
     extend SingleForwardable
 
-    single_delegate [:register, :unregister, :registered?] => :instance
+    single_delegate [
+                        :register,
+                        :unregister,
+                        :registered?,
+                        :debug,
+                        :debug=,
+                        :invoke_handle_callback,
+                        :invoke_timeout_callback
+                    ] => :instance
+
+    attr_accessor :debug
 
     Opaque = Struct.new(:cb, :opaque, :ff)
 
-    class << self
-      def invoke_handle_callback(watch, fd, events, opaque)
-        cb = opaque.cb
-        op = opaque.opaque
-        Util.log(:debug) { "Libvirt::Event INVOKE_HANDLE_CALLBACK watch=#{watch} fd=#{fd} events=#{events} op=#{op}" }
-        cb.call(watch, fd, events, op)
-      end
-
-      def invoke_timeout_callback(timer, opaque)
-        cb = opaque.cb
-        op = opaque.opaque
-        Util.log(:debug) { "Libvirt::Event INVOKE_TIMEOUT_CALLBACK timer=#{timer} op=#{op}" }
-        cb.call(timer, op)
-      end
+    def invoke_handle_callback(watch, fd, events, opaque)
+      cb = opaque.cb
+      op = opaque.opaque
+      dbg { "Libvirt::Event INVOKE_HANDLE_CALLBACK watch=#{watch} fd=#{fd} events=#{events} op=#{op}" }
+      cb.call(watch, fd, events, op)
+    end
+
+    def invoke_timeout_callback(timer, opaque)
+      cb = opaque.cb
+      op = opaque.opaque
+      dbg { "Libvirt::Event INVOKE_TIMEOUT_CALLBACK timer=#{timer} op=#{op}" }
+      cb.call(timer, op)
     end
 
     def registered?
@@ -80,18 +88,18 @@ module Libvirt
     private
 
     def _add_handle(fd, event, cb, opaque, ff)
-      Util.log(:debug) { "Libvirt::Event ADD_HANDLE fd=#{fd}, #{event}=event, cb=#{cb}, opaque=#{opaque}, ff=#{ff}" }
+      dbg { "Libvirt::Event ADD_HANDLE fd=#{fd}, #{event}=event, cb=#{cb}, opaque=#{opaque}, ff=#{ff}" }
       op = Opaque.new(cb, opaque, ff)
       @add_handle.call(fd, event, op)
     end
 
     def _update_handle(watch, event)
-      Util.log(:debug) { "Libvirt::Event UPDATE_HANDLE watch=#{watch}, event=#{event}" }
+      dbg { "Libvirt::Event UPDATE_HANDLE watch=#{watch}, event=#{event}" }
       @update_handle.call(watch, event)
     end
 
     def _remove_handle(watch)
-      Util.log(:debug) { "Libvirt::Event REMOVE_HANDLE watch=#{watch}" }
+      dbg { "Libvirt::Event REMOVE_HANDLE watch=#{watch}" }
       op = @remove_handle.call(watch)
       free_func = op.ff
       opaque = op.opaque
@@ -100,18 +108,18 @@ module Libvirt
     end
 
     def _add_timer(timeout, cb, opaque, ff)
-      Util.log(:debug) { "Libvirt::Event ADD_TIMER timeout=#{timeout}, cb=#{cb}, opaque=#{opaque}, ff=#{ff}" }
+      dbg { "Libvirt::Event ADD_TIMER timeout=#{timeout}, cb=#{cb}, opaque=#{opaque}, ff=#{ff}" }
       op = Opaque.new(cb, opaque, ff)
       @add_timer.call(timeout, op)
     end
 
     def _update_timer(timer, timeout)
-      Util.log(:debug) { "Libvirt::Event UPDATE_TIMER timer=#{timer}, timeout=#{timeout}" }
+      dbg { "Libvirt::Event UPDATE_TIMER timer=#{timer}, timeout=#{timeout}" }
       @update_timer.call(timer, timeout)
     end
 
     def _remove_timer(timer)
-      Util.log(:debug) { "Libvirt::Event REMOVE_TIMER timer=#{timer}" }
+      dbg { "Libvirt::Event REMOVE_TIMER timer=#{timer}" }
       op = @remove_timer.call(timer)
       free_func = op.ff
       opaque = op.opaque
@@ -119,5 +127,11 @@ module Libvirt
       0
     end
 
+    def dbg(&block)
+      return unless debug
+
+      Util.log(:debug, &block)
+    end
+
   end
 end

data/lib/libvirt/ffi/domain.rb

@@ -109,6 +109,14 @@ module Libvirt
       # )
       attach_function :virDomainGetXMLDesc, [:pointer, :uint], :string # strptr?
 
+      # char *virDomainScreenshot (
+      #   virDomainPtr domain,
+      # 	virStreamPtr stream,
+      # 	unsigned int screen,
+      # 	unsigned int flags
+      # )
+      attach_function :virDomainScreenshot, [:pointer, :pointer, :uint, :uint], :strptr
+
       # typedef int	(*virConnectDomainEventCallback) (
       #   virConnectPtr conn,
       # 	virDomainPtr dom,

data/lib/libvirt/ffi/stream.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Libvirt
+  module FFI
+    module Stream
+      extend ::FFI::Library
+      ffi_lib Util.library_path
+
+      # virStreamPtr virStreamNew (
+      #   virConnectPtr conn,
+      # 	unsigned int flags
+      # )
+      attach_function :virStreamNew, [:pointer, :uint], :pointer
+
+      # typedef void (*virStreamEventCallback) (
+      #   virStreamPtr stream,
+      # 	int events,
+      # 	void * opaque
+      # )
+      callback :virStreamEventCallback, [:pointer, :int, :pointer], :void
+
+      # int	virStreamEventAddCallback	(
+      #   virStreamPtr stream,
+      # 	int events,
+      # 	virStreamEventCallback cb,
+      # 	void * opaque,
+      # 	virFreeCallback ff
+      # )
+      attach_function :virStreamEventAddCallback, [
+          :pointer,
+          :int,
+          :virStreamEventCallback,
+          :pointer,
+          FFI::Common::FREE_CALLBACK
+      ], :int
+
+      # int	virStreamEventRemoveCallback (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamEventRemoveCallback, [:pointer], :int
+
+      # int	virStreamEventUpdateCallback (
+      #   virStreamPtr stream,
+      #   int events
+      # )
+      attach_function :virStreamEventUpdateCallback, [:pointer, :int], :int
+
+      # int	virStreamFinish	(
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamFinish, [:pointer], :int
+
+      # int	virStreamFree	(
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamFree, [:pointer], :int
+
+      # int	virStreamAbort (
+      #   virStreamPtr stream
+      # )
+      attach_function :virStreamAbort, [:pointer], :int
+
+      # int	virStreamRecv (
+      #   virStreamPtr stream,
+      # 	char *data,
+      # 	size_t nbytes
+      # )
+      attach_function :virStreamRecv, [:pointer, :pointer, :size_t], :int
+
+    end
+  end
+end

data/lib/libvirt/stream.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Libvirt
+  class Stream
+    NONBLOCK = 0x1
+    EVENT_READABLE = 0x1
+    EVENT_WRITABLE = 0x2
+
+    def initialize(stream_ptr)
+      @stream_ptr = stream_ptr
+      @cb = nil
+      @opaque = nil
+
+      free = ->(obj_id) do
+        STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)}, @stream_ptr=#{@stream_ptr}, @cb=#{@cb},")
+        if @stream_ptr && @cb
+          rm = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
+          STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} rm=#{rm}")
+          ab = FFI::Stream.virStreamAbort(@stream_ptr)
+          STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} ab=#{ab}")
+        end
+        fr = FFI::Stream.virStreamFree(@stream_ptr) if @stream_ptr
+        STDOUT.puts("finalized Libvirt::Stream obj_id=0x#{obj_id.to_s(16)} fr=#{fr}")
+      end
+      ObjectSpace.define_finalizer(self, free)
+    end
+
+    def to_ptr
+      @stream_ptr
+    end
+
+    # @param events [Integer] bit OR of EVENT_READABLE, EVENT_READABLE
+    # @param opaque [Object]
+    # @yield [Stream]
+    def event_add_callback(events, opaque, &block)
+      raise Error, 'callback already added' unless @cb.nil?
+
+      @opaque = opaque
+      @cb = ::FFI::Function.new(:void, [:pointer, :int, :pointer]) do |_stream_ptr, evs, _op|
+        # stream = Stream.new(stream_ptr)
+        block.call(self, evs, @opaque)
+      end
+
+      result = FFI::Stream.virStreamEventAddCallback(@stream_ptr, events, @cb, nil, nil)
+      raise Error, "Couldn't add stream event callback" if result < 0
+
+      true
+    end
+
+    # @param events [Integer] bit OR of EVENT_READABLE, EVENT_READABLE
+    def event_update_callback(events)
+      result = FFI::Stream.virStreamEventUpdateCallback(@stream_ptr, events)
+      raise Error, "Couldn't remove stream event callback" if result < 0
+      true
+    end
+
+    def event_remove_callback
+      result = FFI::Stream.virStreamEventRemoveCallback(@stream_ptr)
+      raise Error, "Couldn't remove stream event callback" if result < 0
+      opaque = @opaque
+      @cb = nil
+      @opaque = nil
+      opaque
+    end
+
+    def finish
+      result = FFI::Stream.virStreamFinish(@stream_ptr)
+      raise Error, "Couldn't remove stream event callback" if result < 0
+      @cb = nil
+      @opaque = nil
+    end
+
+    def abort_stream
+      result = FFI::Stream.virStreamAbort(@stream_ptr)
+      raise Error, "Couldn't remove stream event callback" if result < 0
+      @cb = nil
+      @opaque = nil
+    end
+
+    def recv(bytes)
+      buffer = ::FFI::MemoryPointer.new(:char, bytes)
+      result = FFI::Stream.virStreamRecv(@stream_ptr, buffer, bytes)
+      if result == -1
+        abort_stream
+        [-1, nil]
+      elsif result == 0
+        [0, nil]
+      elsif result == -2
+        [-2, nil]
+      elsif result > 0
+        [result, buffer.read_bytes(result)]
+      else
+        raise Error, "Invalid response from virStreamRecv #{result.inspect}"
+      end
+    end
+  end
+end

data/lib/libvirt/version.rb

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

data/lib/libvirt.rb

@@ -10,10 +10,12 @@ require 'libvirt/ffi/connection'
 require 'libvirt/ffi/domain'
 require 'libvirt/ffi/event'
 require 'libvirt/ffi/node_info'
+require 'libvirt/ffi/stream'
 require 'libvirt/event'
 require 'libvirt/connection'
 require 'libvirt/domain'
 require 'libvirt/node_info'
+require 'libvirt/stream'
 require 'libvirt/version'
 
 module Libvirt

data/test_usage/support/libvirt_async.rb

@@ -1,17 +1,27 @@
 module LibvirtAsync
+  class << self
+    def logger=(logger)
+      @logger = logger
+    end
+
+    def logger
+      @logger
+    end
+  end
+
   module WithDbg
     extend ActiveSupport::Concern
 
     class_methods do
       def dbg(progname = nil, &block)
-        Libvirt.logger.debug(progname || "#{name}.:0x#{object_id.to_s(16)}", &block)
+        LibvirtAsync.logger&.debug(progname || "#{name}.:0x#{object_id.to_s(16)}", &block)
       end
     end
 
     private
 
     def dbg(progname = nil, &block)
-      Libvirt.logger.debug(progname || "#{self.class}#:0x#{object_id.to_s(16)}", &block)
+      LibvirtAsync.logger&.debug(progname || "#{self.class}#:0x#{object_id.to_s(16)}", &block)
     end
   end
 

data/test_usage/test_screenshot.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'libvirt'
+require 'logger'
+require 'active_support/all'
+require 'async'
+require 'get_process_mem'
+
+require_relative 'support/libvirt_async'
+require_relative 'support/log_formatter'
+
+Libvirt.logger = Logger.new(STDOUT, formatter: LogFormatter.new)
+Libvirt.logger.level = ENV['DEBUG'] ? :debug : :info
+
+LibvirtAsync.logger = Logger.new(STDOUT, formatter: LogFormatter.new)
+LibvirtAsync.logger.level = ENV['LIBVIRT_DEBUG'] ? :debug : :info
+
+def print_usage(msg)
+  mem = GetProcessMem.new
+  STDOUT.puts "#{msg} [#{mem.mb}MB]"
+end
+
+def run_gc(msg)
+  print_usage "#{msg} before GC.start"
+  GC.start
+  print_usage "#{msg} after GC.start"
+end
+
+IMPL = LibvirtAsync::Implementations.new
+CONNS = []
+DOMS = []
+STREAMS = { stream: nil }
+
+class ScreenshotOpaque
+  CALLBACK = proc do |s, ev, op|
+    #run_gc('ScreenshotOpaque CALLBACK start')
+    next unless (Libvirt::Stream::EVENT_READABLE & ev) != 0
+    begin
+      code, data = s.recv(1024)
+    rescue Libvirt::Error => e
+      op.on_libvirt_error(s, e)
+      next
+    end
+    #run_gc('ScreenshotOpaque CALLBACK after recv')
+
+    case code
+    when 0
+      op.on_complete(s)
+    when -1
+      op.on_recv_error(s)
+    when -2
+      print_usage "Opaque::CALLBACK #{op.filepath} wait for data"
+    else
+      op.on_receive(data)
+    end
+  end
+
+  attr_reader :filepath
+
+  def initialize(filepath, finish_cb)
+    @filepath = filepath
+    @f = File.open(@filepath, 'wb')
+    @finish_cb = finish_cb
+  end
+
+  def on_complete(stream)
+    print_usage "Opaque#on_complete #{@filepath}"
+    success, reason = finish_stream(stream)
+    finish(success, reason)
+  end
+
+  def on_receive(data)
+    print_usage "Opaque#on_receive #{@filepath} #{data&.size}"
+    @f.write(data)
+  end
+
+  def on_recv_error(stream)
+    print_usage "Opaque#on_recv_error #{@filepath}"
+    success, reason = finish_stream(stream)
+    finish(success, reason)
+  end
+
+  def on_libvirt_error(stream, e)
+    print_usage "Opaque#on_libvirt_error #{@filepath} #{e}"
+    success, reason = finish_stream(stream)
+    finish(success, reason)
+  end
+
+  private
+
+  def finish_stream(stream)
+    print_usage "Opaque#finish_stream stream.event_remove_callback #{@filepath}"
+    stream.event_remove_callback
+    result = begin
+      print_usage "Opaque#finish_stream stream.finish #{@filepath}"
+      stream.finish
+      [true, nil]
+    rescue Libvirt::Error => e
+      STDERR.puts "Opaque#finish_stream stream.finish exception rescued #{e.class} #{e.message}"
+      [false, e.message]
+    end
+    print_usage "Opaque#finish_stream ends #{@filepath}"
+    result
+  end
+
+  def finish(success, reason)
+    print_usage "Opaque#finish success=#{success} #{@filepath}"
+
+    @f.close
+    @f = nil
+    @finish_cb.call(success, reason)
+    @finish_cb = nil
+  end
+end
+
+def save_screenshot(c, domain, i)
+  stream = c.stream(Libvirt::Stream::NONBLOCK)
+
+  opaque_cb = proc do |success|
+    puts "Stream #{i} complete success=#{success}"
+    print_usage "after stream #{i} complete stream=#{STREAMS["stream#{i}"]}"
+    run_gc("Stream #{i} complete before remove stream")
+    print_usage "after stream #{i} complete and GC.start"
+    STREAMS["stream#{i}"] = nil
+    run_gc("Stream #{i} complete before remove stream")
+    print_usage "after stream #{i} delete and GC.start"
+  end
+
+  opaque = ScreenshotOpaque.new("tmp/screenshots_test#{i}.pnm", opaque_cb)
+
+  STREAMS["stream#{i}"] = stream
+
+  print_usage "test_screenshot_mem #{i} before stream start"
+  domain.screenshot(stream, 0)
+  stream.event_add_callback(
+      Libvirt::Stream::EVENT_READABLE,
+      opaque,
+      &ScreenshotOpaque::CALLBACK
+  )
+  run_gc("Stream #{i} after add event")
+end
+
+Async do
+  ASYNC_REACTOR = Async::Task.current.reactor
+
+  puts "Lib version #{Libvirt.lib_version}"
+  puts "Gem version #{Libvirt::VERSION}"
+
+  IMPL.start
+
+  c = Libvirt::Connection.new('qemu+tcp://localhost:16510/system')
+  c.open
+  res = c.set_keep_alive(2, 1)
+  Libvirt.logger.info { "set_keep_alive #{res}" }
+  CONNS.push(c)
+
+  domain = c.list_all_domains.first
+  DOMS.push(domain)
+
+  print_usage "First generation"
+  5.times do |i|
+    save_screenshot(c, domain, 100 + i)
+  end
+
+  ASYNC_REACTOR.after(15) do
+    Async::Task.new(ASYNC_REACTOR, nil) do
+      print_usage "Second generation"
+
+      con = CONNS.first
+      dom = DOMS.first
+      5.times do |i|
+        save_screenshot(con, dom, 200 + i)
+      end
+    end.run
+  end
+
+  ASYNC_REACTOR.after(30) do
+    Async::Task.new(ASYNC_REACTOR, nil) do
+      print_usage "Third generation"
+
+      con = CONNS.first
+      dom = DOMS.first
+      5.times do |i|
+        save_screenshot(con, dom, 300 + i)
+      end
+    end.run
+  end
+
+  ASYNC_REACTOR.every(5) do
+    Async::Task.new(ASYNC_REACTOR, nil) do
+      run_gc 'PERIODIC'
+    end.run
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libvirt_ffi
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Denis Talakevich
@@ -53,7 +53,9 @@ files:
 - lib/libvirt/ffi/event.rb
 - lib/libvirt/ffi/libvirt.rb
 - lib/libvirt/ffi/node_info.rb
+- lib/libvirt/ffi/stream.rb
 - lib/libvirt/node_info.rb
+- lib/libvirt/stream.rb
 - lib/libvirt/util.rb
 - lib/libvirt/version.rb
 - lib/libvirt_ffi.rb
@@ -61,6 +63,7 @@ files:
 - test_usage/support/libvirt_async.rb
 - test_usage/support/log_formatter.rb
 - test_usage/test_event_loop.rb
+- test_usage/test_screenshot.rb
 homepage: https://github.com/senid231/libvirt_ffi
 licenses:
 - MIT