libvirt_async 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2f42eb9b4f528ea66469c50b66465d45b3eaca161c4d6eb82e61c86861a3e884
+  data.tar.gz: 2b6d5b0d8522f4d78e2625841bb00b6587508e370d9baa129abc35811178be15
+SHA512:
+  metadata.gz: 366ca6361b847d440c586d0d6716531f1cc8d295ac7b713cc314b8f2c764993ddf611242848f0d8418156141718bd9a3c7eb20a87f45f4aa092c787d90559f61
+  data.tar.gz: 9d6e5fce3c53248c4248c6097bd2be489505d811f035665c88a81063c27c9041419323015c7f113f8c3226677ee550f7663591aab8aa2925bb258a4602ee1d08

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.8
+before_install: gem install bundler -v 2.1.0

data/CHANGELOG.md

@@ -0,0 +1 @@
+# Changelog

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at senid231@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in libvirt_async.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'
+gem 'minitest', '~> 5.0'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Denis Talakevich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# LibvirtAsync
+
+Libvirt event async implementation.
+Libvirt event api implementation on Fibers based on [libvirt-ruby](https://github.com/qwe/libvirt-ruby) and [async](https://github.com/socketry/async)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'libvirt_async'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install libvirt_async
+
+## Usage
+
+```ruby
+require 'libvirt_async'
+
+LibvirtAsync.use_logger!
+LibvirtAsync.logger.level = Logger::Severity::DEBUG # optional for debugging
+LibvirtAsync.register_implementations!
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. 
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/senid231/libvirt_async. 
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/libvirt_async/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the LibvirtAsync project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/libvirt_async/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'libvirt_async'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/libvirt_async/error.rb

@@ -0,0 +1,4 @@
+module LibvirtAsync
+  class Error < StandardError
+  end
+end

data/lib/libvirt_async/handle.rb

@@ -0,0 +1,193 @@
+module LibvirtAsync
+  class Handle
+    # Represents an event handle (usually a file descriptor).  When an event
+    # happens to the handle, we dispatch the event to libvirt via
+    # Libvirt::event_invoke_handle_callback (feeding it the handle_id we returned
+    # from add_handle, the file descriptor, the new events, and the opaque
+    # data that libvirt gave us earlier).
+
+    class Monitor < Async::Wrapper
+      def close
+        cancel_monitor
+      end
+
+      def readiness
+        monitor&.readiness
+      end
+
+      def to_s
+        "#<#{self.class}:0x#{object_id.to_s(16)} readable=#{@readable&.object_id&.to_s(16)} writable=#{@writable&.object_id&.to_s(16)} alive=#{@monitor && !@monitor.closed?}>"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    include WithDbg
+
+    attr_reader :handle_id, :fd, :opaque, :monitor
+    attr_accessor :events
+
+    def initialize(handle_id, fd, events, opaque)
+      dbg { "#{self.class}#initialize handle_id=#{handle_id}, fd=#{fd}, events=#{events}" }
+
+      @handle_id = handle_id
+      @fd = fd
+      @events = events
+      @opaque = opaque
+      @monitor = nil
+    end
+
+    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
+
+      interest = events_to_interest(events)
+      dbg { "#{self.class}#register parse handle_id=#{handle_id}, fd=#{fd}, events=#{events}, interest=#{interest}" }
+
+      if interest.nil?
+        dbg { "#{self.class}#register no interest handle_id=#{handle_id}, fd=#{fd}" }
+        return
+      end
+
+      task = Util.create_task do
+        dbg { "#{self.class}#register_handle Async start handle_id=#{handle_id}, fd=#{fd}" }
+        io_mode = interest_to_io_mode(interest)
+
+        io = IO.new(fd, io_mode, autoclose: false)
+        @monitor = Monitor.new(io)
+
+        while @monitor.readiness == nil
+          cancelled = wait_io(interest)
+
+          if cancelled
+            dbg { "#{self.class}#register_handle async cancel handle_id=#{handle_id}, fd=#{fd}" }
+            break
+          end
+
+          dbg { "#{self.class}#register_handle async resumes readiness=#{@monitor.readiness}, handle_id=#{handle_id}, fd=#{fd}" }
+          events = readiness_to_events(@monitor.readiness)
+
+          unless events.nil?
+            dispatch(events)
+            break
+          end
+
+          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}" }
+      task.run
+      dbg { "#{self.class}#register_handle ends handle_id=#{handle_id}, fd=#{fd}" }
+    end
+
+    def unregister
+      dbg { "#{self.class}#unregister handle_id=#{handle_id}, fd=#{fd}" }
+
+      if @monitor.nil?
+        dbg { "#{self.class}#unregister already unregistered handle_id=#{handle_id}, fd=#{fd}" }
+        return
+      end
+
+      @monitor.close
+      @monitor = nil
+    end
+
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} handle_id=#{handle_id} fd=#{fd} events=#{events} monitor=#{monitor}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def dispatch(events)
+      dbg { "#{self.class}#dispatch starts handle_id=#{handle_id}, events=#{events}, fd=#{fd}" }
+
+      task = Util.create_task do
+        dbg { "#{self.class}#dispatch async starts handle_id=#{handle_id} events=#{events}, fd=#{fd}" }
+        Libvirt::event_invoke_handle_callback(handle_id, fd, events, opaque)
+        dbg { "#{self.class}#dispatch async ends handle_id=#{handle_id} received_events=#{events}, fd=#{fd}" }
+      end
+      dbg { "#{self.class}#dispatch invokes fiber=0x#{task.fiber.object_id.to_s(16)} handle_id=#{handle_id}, events=#{events}, fd=#{fd}" }
+      task.run
+
+      dbg { "#{self.class}#dispatch ends handle_id=#{handle_id}, events=#{events}, fd=#{fd}" }
+    end
+
+    def wait_io(interest)
+      meth = interest_to_monitor_method(interest)
+      begin
+        @monitor.public_send(meth)
+        false
+      rescue Monitor::Cancelled => e
+        dbg { "#{self.class}#wait_io cancelled #{e.class} #{e.message}" }
+        true
+      end
+    end
+
+    def interest_to_monitor_method(interest)
+      case interest
+      when :r
+        :wait_readable
+      when :w
+        :wait_writable
+      when :rw
+        :wait_any
+      else
+        raise ArgumentError, "invalid interest #{interest}"
+      end
+    end
+
+    def events_to_interest(events)
+      readable = (events & Libvirt::EVENT_HANDLE_READABLE) != 0
+      writable = (events & Libvirt::EVENT_HANDLE_WRITABLE) != 0
+      if readable && writable
+        :rw
+      elsif readable
+        :r
+      elsif writable
+        :w
+      else
+        nil
+      end
+    end
+
+    def interest_to_io_mode(interest)
+      case interest
+      when :rw
+        'a+'
+      when :r
+        'r'
+      when :w
+        'w'
+      else
+        raise ArgumentError, "invalid interest #{interest}"
+      end
+    end
+
+    def readiness_to_events(readiness)
+      case readiness&.to_sym
+      when :rw
+        Libvirt::EVENT_HANDLE_READABLE | Libvirt::EVENT_HANDLE_WRITABLE
+      when :r
+        Libvirt::EVENT_HANDLE_READABLE
+      when :w
+        Libvirt::EVENT_HANDLE_WRITABLE
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/libvirt_async/implementations.rb

@@ -0,0 +1,180 @@
+require 'async'
+require 'libvirt_async/with_dbg'
+require 'libvirt_async/util'
+require 'libvirt_async/handle'
+require 'libvirt_async/timer'
+
+module LibvirtAsync
+  class Implementations
+    include WithDbg
+
+    def initialize
+      dbg { "#{self.class}#initialize" }
+
+      default_variables
+    end
+
+    def start
+      dbg { "#{self.class}#start" }
+
+      register_implementations
+    end
+
+    def stop
+      dbg { "#{self.class}#stop" }
+
+      @handles.each(&:unregister)
+      @timers.each(&:unregister)
+
+      default_variables
+    end
+
+    def print_debug_info
+      str = [
+          "#{self.class}:0x#{object_id.to_s(16)}",
+          "handles = [",
+          @handles.map(&:to_s).join("\n"),
+          "]",
+          "timers = [",
+          @timers.map(&:to_s).join("\n"),
+          "]"
+      ].join("\n")
+      LibvirtAsync.logger&.debug { str }
+    end
+
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} handles=#{@handles} timers=#{@timers}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def default_variables
+      @next_handle_id = 1
+      @next_timer_id = 1
+      @handles = []
+      @timers = []
+    end
+
+    def register_implementations
+      dbg { "#{self.class}#register_implementations" }
+
+      Libvirt::event_register_impl(
+          method(:add_handle).to_proc,
+          method(:update_handle).to_proc,
+          method(:remove_handle).to_proc,
+          method(:add_timer).to_proc,
+          method(:update_timer).to_proc,
+          method(:remove_timer).to_proc
+      )
+    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
+      # callback *must* return the current handle_id.  This handle_id is used
+      # both by libvirt to identify the handle (during an update or remove
+      # callback), and is also passed by the application into libvirt when
+      # dispatching an event.  The application *must* also store the opaque
+      # data given by libvirt, and return it back to libvirt later
+      # (see remove_handle)
+      dbg { "#{self.class}#add_handle starts fd=#{fd}, events=#{events}" }
+
+      @next_handle_id += 1
+      handle_id = @next_handle_id
+      handle = LibvirtAsync::Handle.new(handle_id, fd, events, opaque)
+      @handles << handle
+      handle.register
+
+      dbg { "#{self.class}#add_handle ends fd=#{fd}, events=#{events}" }
+      handle_id
+    end
+
+    def update_handle(handle_id, events)
+      # update a previously registered handle.  Libvirt tells us the handle_id
+      # (which was returned to libvirt via add_handle), and the new events.  It
+      # is our responsibility to find the correct handle and update the events
+      # it cares about
+      dbg { "#{self.class}#update_handle starts handle_id=#{handle_id}, events=#{events}" }
+
+      handle = @handles.detect { |h| h.handle_id == handle_id }
+      handle.events = events
+      handle.unregister
+      handle.register
+
+      dbg { "#{self.class}#update_handle ends handle_id=#{handle_id}, events=#{events}" }
+      nil
+    end
+
+    def remove_handle(handle_id)
+      # remove a previously registered handle.  Libvirt tells us the handle_id
+      # (which was returned to libvirt via add_handle), and it is our
+      # responsibility to "forget" the handle.  We must return the opaque data
+      # that libvirt handed us in "add_handle", otherwise we will leak memory
+      dbg { "#{self.class}#remove_handle starts handle_id=#{handle_id}" }
+
+      idx = @handles.index { |h| h.handle_id == handle_id }
+      handle = @handles.delete_at(idx)
+      handle.unregister
+
+      dbg { "#{self.class}#remove_handle starts handle_id=#{handle_id}" }
+      handle.opaque
+    end
+
+    def add_timer(interval, opaque)
+      # add a timeout to be tracked by this object.  The application is
+      # expected to maintain a list of internal timer IDs (integers); this
+      # callback *must* return the current timer_id.  This timer_id is used
+      # both by libvirt to identify the timeout (during an update or remove
+      # callback), and is also passed by the application into libvirt when
+      # dispatching an event.  The application *must* also store the opaque
+      # data given by libvirt, and return it back to libvirt later
+      # (see remove_timer)
+      dbg { "#{self.class}#add_timer starts interval=#{interval}" }
+
+      @next_timer_id += 1
+      timer_id = @next_timer_id
+      timer = LibvirtAsync::Timer.new(timer_id, interval, opaque)
+      @timers << timer
+      timer.register
+
+      dbg { "#{self.class}#add_timer ends interval=#{interval}" }
+      timer_id
+    end
+
+    def update_timer(timer_id, interval)
+      # update a previously registered timer.  Libvirt tells us the timer_id
+      # (which was returned to libvirt via add_timer), and the new interval.  It
+      # is our responsibility to find the correct timer and update the timers
+      # it cares about
+      dbg { "#{self.class}#update_timer starts timer_id=#{timer_id}, interval=#{interval}" }
+
+      timer = @timers.detect { |t| t.timer_id == timer_id }
+      dbg { "#{self.class}#update_timer updating timer_id=#{timer.timer_id}" }
+      timer.interval = interval
+      timer.unregister
+      timer.register
+
+      dbg { "#{self.class}#update_timer ends timer_id=#{timer_id}, interval=#{interval}" }
+      nil
+    end
+
+    def remove_timer(timer_id)
+      # remove a previously registered timeout.  Libvirt tells us the timer_id
+      # (which was returned to libvirt via add_timer), and it is our
+      # responsibility to "forget" the timer.  We must return the opaque data
+      # that libvirt handed us in "add_timer", otherwise we will leak memory
+      dbg { "#{self.class}#remove_timer starts timer_id=#{timer_id}" }
+
+      idx = @timers.index { |t| t.timer_id == timer_id }
+      timer = @timers.delete_at(idx)
+      timer.unregister
+
+      dbg { "#{self.class}#remove_timer ends timer_id=#{timer_id}" }
+      timer.opaque
+    end
+  end
+end

data/lib/libvirt_async/log_formatter.rb

@@ -0,0 +1,40 @@
+module LibvirtAsync
+  class LogFormatter
+    LOG_FORMAT = "%s, %s [%d/%s/%s] %s\n".freeze
+    DEFAULT_DATETIME_FORMAT = "%F %T.%N".freeze
+
+    attr_accessor :datetime_format
+
+    def initialize
+      @datetime_format = nil
+    end
+
+    def call(severity, time, progname, message)
+      LOG_FORMAT % [
+          severity[0..0],
+          format_datetime(time),
+          Process.pid,
+          "0x#{Fiber.current.object_id.to_s(16)}",
+          progname,
+          format_message(message)
+      ]
+    end
+
+    private
+
+    def format_datetime(time)
+      time.strftime(@datetime_format || DEFAULT_DATETIME_FORMAT)
+    end
+
+    def format_message(message)
+      case message
+      when ::String
+        message
+      when ::Exception
+        "<#{message.class}>:#{message.message}\n#{(message.backtrace || []).join("\n")}"
+      else
+        message.inspect
+      end
+    end
+  end
+end

data/lib/libvirt_async/timer.rb

@@ -0,0 +1,138 @@
+module LibvirtAsync
+  class Timer
+    # Represents a   When a timer expires, we dispatch the event to
+    # libvirt via Libvirt::event_invoke_timeout_callback (feeding it the timer_id
+    # we returned from add_timer and the opaque data that libvirt gave us
+    # earlier).
+
+    class Monitor
+      class Cancelled < StandardError
+        def initialize
+          super('was cancelled')
+        end
+      end
+
+      attr_reader :fiber
+
+      def initialize
+        @fiber = nil
+      end
+
+      def wait(timeout)
+        @fiber = Async::Task.current.fiber
+        Async::Task.current.sleep(timeout)
+        @fiber = nil
+      end
+
+      def close
+        @fiber.resume(Cancelled.new) if @fiber&.alive?
+        @fiber = nil
+      end
+
+      def to_s
+        "#<#{self.class}:0x#{object_id.to_s(16)} fiber=#{@fiber.&object_id&.to_s(16)} alive=#{@fiber&.alive?}>"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    include WithDbg
+
+    attr_reader :timer_id, :opaque, :monitor
+    attr_accessor :last_fired, :interval
+
+    def initialize(timer_id, interval, opaque)
+      dbg { "#{self.class}#initialize timer_id=#{timer_id}, interval=#{interval}" }
+
+      @timer_id = timer_id
+      @interval = interval.to_f / 1000.to_f
+      @opaque = opaque
+      @last_fired = Time.now.to_f
+      @monitor = nil
+    end
+
+    def wait_time
+      return if interval < 0
+      last_fired + interval
+    end
+
+    def register
+      dbg { "#{self.class}#register starts timer_id=#{timer_id}, interval=#{interval}" }
+
+      if wait_time.nil?
+        dbg { "#{self.class}#register no wait time timer_id=#{timer_id}, interval=#{interval}" }
+        return
+      end
+
+      task = Util.create_task do
+        dbg { "#{self.class}#register async starts timer_id=#{timer_id}, interval=#{interval}" }
+        now_time = Time.now.to_f
+        timeout = wait_time > now_time ? wait_time - now_time : 0
+        @monitor = Monitor.new
+        cancelled = wait_timer(timeout)
+
+        if cancelled
+          dbg { "#{self.class}#register async cancel timer_id=#{timer_id}, interval=#{interval}" }
+        else
+          dbg { "#{self.class}#register async ready timer_id=#{timer_id}, interval=#{interval}" }
+          self.last_fired = Time.now.to_f
+          dispatch
+        end
+      end
+
+      dbg { "#{self.class}#register invokes fiber=0x#{task.fiber.object_id.to_s(16)} timer_id=#{timer_id}, interval=#{interval}" }
+      task.run
+      dbg { "#{self.class}#register ends timer_id=#{timer_id}, interval=#{interval}" }
+    end
+
+    def unregister
+      dbg { "#{self.class}#unregister_timer timer_id=#{timer_id}, interval=#{interval}" }
+
+      if @monitor.nil?
+        dbg { "#{self.class}#unregister_timer already unregistered timer_id=#{timer_id}, interval=#{interval}" }
+        return
+      end
+
+      @monitor.close
+      @monitor = nil
+    end
+
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} timer_id=#{timer_id} interval=#{interval} last_fired=#{last_fired} monitor=#{monitor}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    private
+
+    def dispatch
+      dbg { "#{self.class}#dispatch starts timer_id=#{timer_id}, interval=#{interval}" }
+
+      task = Util.create_task do
+        dbg { "#{self.class}#dispatch async starts timer_id=#{timer_id}, interval=#{interval}" }
+        Libvirt::event_invoke_timeout_callback(timer_id, opaque)
+        dbg { "#{self.class}#dispatch async async ends timer_id=#{timer_id}, interval=#{interval}" }
+      end
+
+      dbg { "#{self.class}#dispatch invokes fiber=0x#{task.fiber.object_id.to_s(16)} timer_id=#{timer_id}, interval=#{interval}" }
+      task.run
+
+      dbg { "#{self.class}#dispatch ends timer_id=#{timer_id}, interval=#{interval}" }
+    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
+    end
+
+  end
+end

data/lib/libvirt_async/util.rb

@@ -0,0 +1,11 @@
+module LibvirtAsync
+  module Util
+
+    def create_task(&block)
+      Async::Task.new(Async::Task.current.reactor, &block)
+    end
+
+    module_function :create_task
+
+  end
+end

data/lib/libvirt_async/version.rb

@@ -0,0 +1,3 @@
+module LibvirtAsync
+  VERSION = '0.1.0'
+end

data/lib/libvirt_async/with_dbg.rb

@@ -0,0 +1,19 @@
+require 'active_support/concern'
+
+module LibvirtAsync
+  module WithDbg
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def dbg(progname = nil, &block)
+        LibvirtAsync.logger&.debug(progname || "0x#{object_id.to_s(16)}", &block)
+      end
+    end
+
+    private
+
+    def dbg(progname = nil, &block)
+      LibvirtAsync.logger&.debug(progname || "0x#{object_id.to_s(16)}", &block)
+    end
+  end
+end

data/lib/libvirt_async.rb

@@ -0,0 +1,77 @@
+require 'libvirt_async/version'
+require 'libvirt_async/error'
+require 'libvirt_async/log_formatter'
+require 'libvirt_async/implementations'
+
+module LibvirtAsync
+  def register_implementations!
+    return false unless @implementations.nil?
+
+    @implementations = Implementations.new
+    @implementations.start
+    true
+  end
+
+  module_function :register_implementations!
+
+  def unregister_implementations!
+    return false if @implementations.nil?
+    @implementations.stop
+    @implementations = nil
+    true
+  end
+
+  module_function :unregister_implementations!
+
+  def logger=(value)
+    @logger = value
+  end
+
+  module_function :logger=
+
+  def logger
+    @logger
+  end
+
+  module_function :logger
+
+  def build_logger(io, formatter: LogFormatter.new, progname: nil, level: :info, datetime_format: nil)
+    formatter&.datetime_format = datetime_format unless datetime_format.nil?
+    logger = Logger.new(io, formatter: formatter, progname: progname, level: level)
+    logger
+  end
+
+  module_function :build_logger
+
+  def use_logger!(io = STDOUT, options = {})
+    self.logger = build_logger(io, options)
+  end
+
+  module_function :use_logger!
+
+  def start_debug_logging!(timeout = 2)
+    LibvirtAsync.logger.debug { "scheduling debug logging!" }
+    @debug_task = Util.create_task do
+      LibvirtAsync.logger.debug { "starting debug logging!" }
+      begin
+        while true do
+          raise Error, 'implementations not registered' if @implementations.nil?
+          @implementations.print_debug_info
+          Async::Task.current.reactor.sleep timeout
+        end
+      rescue Error => e
+        LibvirtAsync.logger.debug { "stopping debug logging! #{e.message}" }
+      end
+    end
+    Async::Task.current.reactor << @debug_task.fiber
+  end
+
+  module_function :start_debug_logging!
+
+  def stop_debug_logging!
+    @debug_task&.stop(true)
+    @debug_task = nil
+  end
+
+  module_function :stop_debug_logging!
+end

data/libvirt_async.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/libvirt_async/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'libvirt_async'
+  spec.version       = LibvirtAsync::VERSION
+  spec.authors       = ['Denis Talakevich']
+  spec.email         = ['senid231@gmail.com']
+
+  spec.summary       = 'Libvirt event async implementation.'
+  spec.description   = 'Libvirt event implementation on Fibers based on libvirt-ruby and async gems.'
+  spec.homepage      = 'https://github.com/senid231/libvirt_async'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/CHANGELOG.md"
+
+  # 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
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'ruby-libvirt', '~> 0.7'
+  spec.add_dependency 'async', '~> 1.24'
+  spec.add_dependency 'activesupport'
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: libvirt_async
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Talakevich
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-libvirt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.24'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Libvirt event implementation on Fibers based on libvirt-ruby and async
+  gems.
+email:
+- senid231@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/libvirt_async.rb
+- lib/libvirt_async/error.rb
+- lib/libvirt_async/handle.rb
+- lib/libvirt_async/implementations.rb
+- lib/libvirt_async/log_formatter.rb
+- lib/libvirt_async/timer.rb
+- lib/libvirt_async/util.rb
+- lib/libvirt_async/version.rb
+- lib/libvirt_async/with_dbg.rb
+- libvirt_async.gemspec
+homepage: https://github.com/senid231/libvirt_async
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/senid231/libvirt_async
+  source_code_uri: https://github.com/senid231/libvirt_async
+  changelog_uri: https://github.com/senid231/libvirt_async/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Libvirt event async implementation.
+test_files: []