libvirt_ffi 0.6.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43c4cf7b7fa510b96605a9f05e8f04680280459d48572085740a71f145ce1442
-  data.tar.gz: a3ca5f72fdeb7de0cc95b440f58c5b894970add2cb746c12e3191d12269dcc42
+  metadata.gz: d81d03c71f0077138bdc7369c7468138333eb45ae1de85c857089b263975e8c4
+  data.tar.gz: cdae17b6ecb8174ee12247d31d4419a9bf367ba17a460c6f9e3e5cc347d313ca
 SHA512:
-  metadata.gz: f1b7448f8ebd67349c59a365d1b30072bf99d5f78ffc1b07c87f99a312365f4d42474e62886c71e797fd0deab4c6f726af6440d6c4bb350fb8a65ee751b68ed5
-  data.tar.gz: 24056f945020275a102517bd6f4fba560be15c0f4fea7725b9c4b9b6032a1e94695b1520094c4027bf4ea0e34291e00148efefbb60d114640980e6c69e9f6cae
+  metadata.gz: 4f2a8d886ed935f536bd5e04fd9e710d953d0f7f78a8e408220018784291ac3ba71f2e342dcaedbe44b3b57c2e1c77cd36784a05f9d6a0b486ddc6b1dfeb1bd3
+  data.tar.gz: 3df70b41610251d35c2986ba77fd617ee15cb956dc690f850b4650ac34ef4fee80072987d83b1cefcf806501fd87e6401def2c2d2d120e5d8db1b09136d21742

data/.github/workflows/tests.yml

@@ -0,0 +1,26 @@
+name: Tests
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ '2.6', '2.7', '3.0' ]
+    name: Tests with Ruby ${{ matrix.ruby }}
+    steps:
+      - name: Install libvirt
+        run: sudo apt-get install -y libvirt-dev libvirt0
+      - uses: actions/checkout@v2
+      - uses: actions/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Run tests
+        run: |
+          gem install bundler
+          bundle install
+          bundle exec rake

data/.gitignore

@@ -6,5 +6,6 @@
 /pkg/
 /spec/reports/
 /tmp/
-
 /Gemfile.lock
+.rspec_local
+/spec/last_run.txt

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -5,7 +5,7 @@ AllCops:
     - vendor/**/*
     - tmp/**/*
     - pkg/*
-    - test_usage/**/*.rb
+    - examples/**/*.rb
 
 Layout/LineLength:
   Max: 180

data/Gemfile

@@ -5,14 +5,11 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in libvirt.gemspec
 gemspec
 
-gem 'minitest', '~> 5.0'
-gem 'rake', '~> 12.0'
-
+gem 'activesupport'
+gem 'async', '~> 1.24'
+gem 'gc_tracer'
+gem 'get_process_mem'
 gem 'nokogiri'
-
-group :development do
-  gem 'activesupport'
-  gem 'async', '~> 1.24'
-  gem 'gc_tracer'
-  gem 'get_process_mem'
-end
+gem 'rake', '~> 12.0'
+gem 'rspec', '~> 3.9'
+gem 'rubocop', '~> 0.80.1'

data/README.md

@@ -32,7 +32,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/libvirt. 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/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/senid231/libvirt. 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/senid231/libvirt/blob/master/CODE_OF_CONDUCT.md).
 
 
 ## License
@@ -41,4 +41,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Libvirt project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/libvirt/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Libvirt project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/senid231/libvirt/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -1,15 +1,10 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
+RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new(:rubocop)
 
-task default: [:rubocop, :test]
+task default: [:rubocop, :spec]

data/lib/libvirt/base_info.rb

@@ -16,6 +16,7 @@ module Libvirt
       end
     end
 
+    # @param pointer [FFI::Pointer]
     def initialize(pointer)
       raise ArgumentError, "Can't initialize base class #{self.class}" if self.class == BaseInfo
 
@@ -23,12 +24,19 @@ module Libvirt
       @struct = self.class._struct_class.new(pointer)
     end
 
+    # @param attr [Symbol]
+    # @return [Object, nil]
     def [](attr)
       @struct[attr]
     end
 
+    # @return [Hash]
     def to_h
       @struct.members.map { |attr| [attr, @struct[attr]] }.to_h
     end
+
+    def to_ptr
+      @struct.to_ptr
+    end
   end
 end

data/lib/libvirt/connection.rb

@@ -2,11 +2,15 @@
 
 module Libvirt
   class Connection
+    include Loggable
+
     DOMAIN_EVENT_IDS = FFI::Domain.enum_type(:event_id).symbols.dup.freeze
     POOL_EVENT_IDS = FFI::Storage.enum_type(:event_id).symbols.dup.freeze
+    NETWORK_EVENT_IDS = FFI::Network.enum_type(:event_id).symbols.dup.freeze
 
     DOMAIN_STORAGE = HostCallbackStorage.new(:domain_event)
     POOL_STORAGE = HostCallbackStorage.new(:storage_pool_event)
+    NETWORK_STORAGE = HostCallbackStorage.new(:network_event)
     CLOSE_STORAGE = HostCallbackStorage.new(:close)
 
     DOMAIN_EVENT_CALLBACKS = DOMAIN_EVENT_IDS.map do |event_id_sym|
@@ -35,6 +39,19 @@ module Libvirt
       [event_id_sym, func]
     end.to_h.freeze
 
+    NETWORK_EVENT_CALLBACKS = NETWORK_EVENT_IDS.map do |event_id_sym|
+      func = FFI::Network.event_callback_for(event_id_sym) do |conn_ptr, pool_ptr, *args, op_ptr|
+        Util.log(:debug, "NETWORK_EVENT_CALLBACKS[#{event_id_sym}]") do
+          "inside callback conn_ptr=#{conn_ptr}, pool_ptr=#{pool_ptr}, args=#{args}, op_ptr=#{op_ptr}"
+        end
+        connection = Connection.load_ref(conn_ptr)
+        pool = Network.load_ref(pool_ptr)
+        block, opaque = NETWORK_STORAGE.retrieve_from_pointer(op_ptr)
+        block.call(connection, pool, *args, opaque)
+      end
+      [event_id_sym, func]
+    end.to_h.freeze
+
     CLOSE_CALLBACK = FFI::Host.callback_function(:virConnectCloseFunc) do |conn_ptr, reason, op_ptr|
       Util.log(:debug, 'CLOSE_CALLBACK') { "inside callback conn_ptr=#{conn_ptr}, reason=#{reason}, op_ptr=#{op_ptr}" }
       connection = Connection.load_ref(conn_ptr)
@@ -42,56 +59,68 @@ module Libvirt
       block.call(connection, reason, opaque)
     end
 
-    def self.load_ref(conn_ptr)
-      ref_result = FFI::Host.virConnectRef(conn_ptr)
-      raise Errors::LibError, "Couldn't retrieve connection reference" if ref_result.negative?
+    def self.load_ref(ptr)
+      result = FFI::Host.virConnectRef(ptr)
+      raise Errors::LibError, "Couldn't retrieve connection reference" if result.negative?
 
-      new(nil).tap { |r| r.send(:set_connection, conn_ptr) }
+      uri = FFI::Host.virConnectGetURI(ptr)
+      new(uri).tap { |c| c.instance_variable_set(:@ptr, ptr) }
     end
 
+    attr_reader :uri
+
     def initialize(uri)
       @uri = uri
-      @conn_ptr = ::FFI::Pointer.new(0)
+      @ptr = ::FFI::Pointer.new(0)
       @close_data = nil
 
-      free = ->(obj_id) do
-        Util.log(:debug) { "Finalize Libvirt::Connection 0x#{obj_id.to_s(16)} @conn_ptr=#{@conn_ptr}," }
-        return if @conn_ptr.null?
+      Util.define_finalizer(self) { |pointer| FFI::Host.virConnectClose(pointer) }
+    end
 
-        cl_result = FFI::Host.virConnectClose(@conn_ptr)
-        warn "Couldn't close Libvirt::Connection (0x#{obj_id.to_s(16)}) pointer #{@conn_ptr.address}" if cl_result.negative?
-      end
-      ObjectSpace.define_finalizer(self, free)
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)} @uri=#{@uri.inspect} @ptr=0x#{@ptr.address.to_s(16)}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_ptr
+      @ptr
     end
 
     def open
-      @conn_ptr = FFI::Host.virConnectOpen(@uri)
-      raise Errors::LibError, "Couldn't open connection to #{@uri.inspect}" if @conn_ptr.null?
+      @ptr = FFI::Host.virConnectOpen(@uri)
+      raise Errors::LibError, "Couldn't open connection to #{@uri.inspect}" if @ptr.null?
+
+      dbg { 'opened' }
 
       true
     end
 
     def close
-      result = FFI::Host.virConnectClose(@conn_ptr)
+      result = FFI::Host.virConnectClose(@ptr)
       raise Errors::LibError, "Couldn't close connection to #{@uri.inspect}" if result.negative?
 
-      @conn_ptr = ::FFI::Pointer.new(0)
+      dbg { 'closed' }
+
+      @ptr = ::FFI::Pointer.new(0)
       true
     end
 
     def opened?
-      !@conn_ptr.null?
+      !@ptr.null?
     end
 
-    def to_ptr
-      @conn_ptr
+    def closed?
+      !opened?
     end
 
     def version
       check_open!
 
       version_ptr = ::FFI::MemoryPointer.new(:ulong)
-      result = FFI::Host.virConnectGetVersion(@conn_ptr, version_ptr)
+      result = FFI::Host.virConnectGetVersion(@ptr, version_ptr)
       raise Errors::LibError, "Couldn't retrieve connection version" if result.negative?
 
       version_number = version_ptr.get_ulong(0)
@@ -99,29 +128,21 @@ module Libvirt
     end
 
     def set_keep_alive(interval, count)
-      result = FFI::Host.virConnectSetKeepAlive(@conn_ptr, interval, count)
+      result = FFI::Host.virConnectSetKeepAlive(@ptr, interval, count)
       raise Errors::LibError, "Couldn't set connection keep_alive" if result.negative?
 
       result.zero?
     end
 
     def free_memory
-      result = FFI::Host.virNodeGetFreeMemory(@conn_ptr)
+      result = FFI::Host.virNodeGetFreeMemory(@ptr)
       raise Errors::LibError, "Couldn't set connection keep_alive" if result.negative?
 
       result
     end
 
-    def to_s
-      "#<#{self.class}:0x#{object_id.to_s(16)} @uri=#{@uri.inspect} @conn_ptr=0x#{@conn_ptr.address.to_s(16)}>"
-    end
-
-    def inspect
-      to_s
-    end
-
     def list_all_domains_qty(flags = 0)
-      result = FFI::Domain.virConnectListAllDomains(@conn_ptr, nil, flags)
+      result = FFI::Domain.virConnectListAllDomains(@ptr, nil, flags)
       raise Errors::LibError, "Couldn't retrieve domains qty with flags #{flags.to_s(16)}" if result.negative?
 
       result
@@ -132,7 +153,7 @@ module Libvirt
       return [] if size.zero?
 
       domains_ptr = ::FFI::MemoryPointer.new(:pointer, size)
-      result = FFI::Domain.virConnectListAllDomains(@conn_ptr, domains_ptr, flags)
+      result = FFI::Domain.virConnectListAllDomains(@ptr, domains_ptr, flags)
       raise Errors::LibError, "Couldn't retrieve domains list with flags #{flags.to_s(16)}" if result.negative?
 
       ptr = domains_ptr.read_pointer
@@ -141,7 +162,7 @@ module Libvirt
 
     def list_all_storage_pools_qty(options_or_flags = nil)
       flags = Util.parse_flags options_or_flags, FFI::Storage.enum_type(:list_all_pools_flags)
-      result = FFI::Storage.virConnectListAllStoragePools(@conn_ptr, nil, flags)
+      result = FFI::Storage.virConnectListAllStoragePools(@ptr, nil, flags)
       raise Errors::LibError, "Couldn't retrieve storage pools qty with flags #{flags.to_s(16)}" if result.negative?
 
       result
@@ -153,19 +174,73 @@ module Libvirt
       return [] if size.zero?
 
       storage_pools_ptr = ::FFI::MemoryPointer.new(:pointer, size)
-      result = FFI::Storage.virConnectListAllStoragePools(@conn_ptr, storage_pools_ptr, flags)
+      result = FFI::Storage.virConnectListAllStoragePools(@ptr, storage_pools_ptr, flags)
       raise Errors::LibError, "Couldn't retrieve storage pools list with flags #{flags.to_s(16)}" if result.negative?
 
       ptr = storage_pools_ptr.read_pointer
       ptr.get_array_of_pointer(0, size).map { |stp_ptr| StoragePool.new(stp_ptr) }
     end
 
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Integer]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_networks_qty(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Network.enum_type(:list_all_flags)
+      result = FFI::Network.virConnectListAllNetworks(@ptr, nil, flags)
+      raise Errors::LibError, "Couldn't retrieve networks qty with flags #{flags.to_s(16)}" if result.negative?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Array<Libvirt::Network>, Array]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_networks(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Network.enum_type(:list_all_flags)
+      size = list_all_networks_qty(flags)
+      return [] if size.zero?
+
+      networks_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Network.virConnectListAllNetworks(@ptr, networks_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve networks list" if result.negative?
+
+      ptr = networks_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |n_ptr| Network.new(n_ptr) }
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Integer]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_interfaces_qty(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Interface.enum_type(:list_all_flags)
+      result = FFI::Interface.virConnectListAllInterfaces(@ptr, nil, flags)
+      raise Errors::LibError, "Couldn't retrieve interfaces qty with flags #{flags.to_s(16)}" if result.negative?
+
+      result
+    end
+
+    # @param options_or_flags [Array<Symbol>,Hash{Symbol=>Boolean},Integer,Symbol,nil]
+    # @return [Array<Libvirt::Interface>, Array]
+    # @raise [Libvirt::Errors::LibError]
+    def list_all_interfaces(options_or_flags = nil)
+      flags = Util.parse_flags options_or_flags, FFI::Interface.enum_type(:list_all_flags)
+      size = list_all_interfaces_qty(flags)
+      return [] if size.zero?
+
+      interfaces_ptr = ::FFI::MemoryPointer.new(:pointer, size)
+      result = FFI::Interface.virConnectListAllInterfaces(@ptr, interfaces_ptr, 0)
+      raise Errors::LibError, "Couldn't retrieve interfaces list" if result.negative?
+
+      ptr = interfaces_ptr.read_pointer
+      ptr.get_array_of_pointer(0, size).map { |i_ptr| Interface.new(i_ptr) }
+    end
+
     def register_close_callback(opaque = nil, &block)
-      dbg { "#register_close_callback opaque=#{opaque}" }
+      dbg { "opaque=#{opaque}" }
 
       cb_data, cb_data_free_func = CLOSE_STORAGE.allocate_struct
       result = FFI::Host.virConnectRegisterCloseCallback(
-          @conn_ptr,
+          @ptr,
           CLOSE_CALLBACK,
           cb_data.pointer,
           cb_data_free_func
@@ -177,17 +252,29 @@ module Libvirt
 
       CLOSE_STORAGE.store_struct(
           cb_data,
-          connection_pointer: @conn_ptr,
+          connection_pointer: @ptr,
           callback_id: result,
           cb: block,
-          opaque: opaque
+          opaque: opaque,
+          free_func: cb_data_free_func
       )
       result
     end
 
+    def deregister_close_callback
+      dbg { 'deregister' }
+
+      result = FFI::Host.virConnectUnregisterCloseCallback(@ptr, CLOSE_CALLBACK)
+      raise Errors::LibError, "Couldn't deregister close callback" if result.negative?
+
+      # virConnectUnregisterCloseCallback will call free func
+      # So we don't need to remove object from CLOSE_STORAGE here.
+      true
+    end
+
     # @yield conn, dom, *args
     def register_domain_event_callback(event_id, domain = nil, opaque = nil, &block)
-      dbg { "#register_domain_event_callback event_id=#{event_id}" }
+      dbg { "event_id=#{event_id}" }
 
       enum = FFI::Domain.enum_type(:event_id)
       event_id, event_id_sym = Util.parse_enum(enum, event_id)
@@ -196,7 +283,7 @@ module Libvirt
       cb_data, cb_data_free_func = DOMAIN_STORAGE.allocate_struct
 
       result = FFI::Domain.virConnectDomainEventRegisterAny(
-          @conn_ptr,
+          @ptr,
           domain&.to_ptr,
           event_id,
           cb,
@@ -213,15 +300,16 @@ module Libvirt
           connection_pointer: @conn_ptr,
           callback_id: result,
           cb: block,
-          opaque: opaque
+          opaque: opaque,
+          free_func: cb_data_free_func
       )
       result
     end
 
     def deregister_domain_event_callback(callback_id)
-      dbg { "#deregister_domain_event_callback callback_id=#{callback_id}" }
+      dbg { "callback_id=#{callback_id}" }
 
-      result = FFI::Domain.virConnectDomainEventDeregisterAny(@conn_ptr, callback_id)
+      result = FFI::Domain.virConnectDomainEventDeregisterAny(@ptr, callback_id)
       raise Errors::LibError, "Couldn't deregister domain event callback" if result.negative?
 
       # virConnectDomainEventDeregisterAny will call free func
@@ -230,7 +318,7 @@ module Libvirt
     end
 
     def register_storage_pool_event_callback(event_id, storage_pool = nil, opaque = nil, &block)
-      dbg { "#register_storage_pool_event_callback event_id=#{event_id}" }
+      dbg { "event_id=#{event_id}" }
 
       enum = FFI::Storage.enum_type(:event_id)
       event_id, event_id_sym = Util.parse_enum(enum, event_id)
@@ -239,7 +327,7 @@ module Libvirt
       cb_data, cb_data_free_func = POOL_STORAGE.allocate_struct
 
       result = FFI::Storage.virConnectStoragePoolEventRegisterAny(
-          @conn_ptr,
+          @ptr,
           storage_pool&.to_ptr,
           event_id,
           cb,
@@ -253,18 +341,19 @@ module Libvirt
 
       POOL_STORAGE.store_struct(
           cb_data,
-          connection_pointer: @conn_ptr,
+          connection_pointer: @ptr,
           callback_id: result,
           cb: block,
-          opaque: opaque
+          opaque: opaque,
+          free_func: cb_data_free_func
       )
       result
     end
 
     def deregister_storage_pool_event_callback(callback_id)
-      dbg { "#deregister_storage_pool_event_callback callback_id=#{callback_id}" }
+      dbg { "callback_id=#{callback_id}" }
 
-      result = FFI::Storage.virConnectStoragePoolEventDeregisterAny(@conn_ptr, callback_id)
+      result = FFI::Storage.virConnectStoragePoolEventDeregisterAny(@ptr, callback_id)
       raise Errors::LibError, "Couldn't deregister storage pool event callback" if result.negative?
 
       # virConnectStoragePoolEventDeregisterAny will call free func
@@ -272,20 +361,53 @@ module Libvirt
       true
     end
 
-    def deregister_close_callback
-      dbg { '#deregister_close_callback' }
+    def register_network_event_callback(event_id, network = nil, opaque = nil, &block)
+      dbg { "event_id=#{event_id}" }
 
-      result = FFI::Host.virConnectUnregisterCloseCallback(@conn_ptr, CLOSE_CALLBACK)
-      raise Errors::LibError, "Couldn't deregister close callback" if result.negative?
+      enum = FFI::Network.enum_type(:event_id)
+      event_id, event_id_sym = Util.parse_enum(enum, event_id)
+      cb = NETWORK_EVENT_CALLBACKS.fetch(event_id_sym)
 
-      # virConnectUnregisterCloseCallback will call free func
-      # So we don't need to remove object from CLOSE_STORAGE here.
+      cb_data, cb_data_free_func = NETWORK_STORAGE.allocate_struct
+
+      result = FFI::Network.virConnectNetworkEventRegisterAny(
+          @ptr,
+          network&.to_ptr,
+          event_id,
+          cb,
+          cb_data.pointer,
+          cb_data_free_func
+      )
+      if result.negative?
+        cb_data.pointer.free
+        raise Errors::LibError, "Couldn't register network event callback"
+      end
+
+      NETWORK_STORAGE.store_struct(
+          cb_data,
+          connection_pointer: @ptr,
+          callback_id: result,
+          cb: block,
+          opaque: opaque,
+          free_func: cb_data_free_func
+      )
+      result
+    end
+
+    def deregister_network_event_callback(callback_id)
+      dbg { "callback_id=#{callback_id}" }
+
+      result = FFI::Network.virConnectNetworkEventDeregisterAny(@ptr, callback_id)
+      raise Errors::LibError, "Couldn't deregister network event callback" if result.negative?
+
+      # virConnectNetworkEventDeregisterAny will call free func
+      # So we don't need to remove object from NETWORK_STORAGE here.
       true
     end
 
     def lib_version
       version_ptr = ::FFI::MemoryPointer.new(:ulong)
-      result = FFI::Host.virConnectGetLibVersion(@conn_ptr, version_ptr)
+      result = FFI::Host.virConnectGetLibVersion(@ptr, version_ptr)
       raise Errors::LibError, "Couldn't get connection lib version" if result.negative?
 
       version_number = version_ptr.get_ulong(0)
@@ -293,28 +415,28 @@ module Libvirt
     end
 
     def hostname
-      FFI::Host.virConnectGetHostname(@conn_ptr)
+      FFI::Host.virConnectGetHostname(@ptr)
     end
 
     # @param type [String,NilClass]
     def max_vcpus(type = nil)
-      FFI::Host.virConnectGetMaxVcpus(@conn_ptr, type)
+      FFI::Host.virConnectGetMaxVcpus(@ptr, type)
     end
 
     def capabilities
-      FFI::Host.virConnectGetCapabilities(@conn_ptr)
+      FFI::Host.virConnectGetCapabilities(@ptr)
     end
 
     def node_info
       node_info_ptr = ::FFI::MemoryPointer.new(FFI::Host::NodeInfoStruct.by_value)
-      result = FFI::Host.virNodeGetInfo(@conn_ptr, node_info_ptr)
+      result = FFI::Host.virNodeGetInfo(@ptr, node_info_ptr)
       raise Errors::LibError, "Couldn't get connection node info" if result.negative?
 
       NodeInfo.new(node_info_ptr)
     end
 
     def stream(flags = 0)
-      pointer = FFI::Stream.virStreamNew(@conn_ptr, flags)
+      pointer = FFI::Stream.virStreamNew(@ptr, flags)
       raise Errors::LibError, "Couldn't create stream" if pointer.null?
 
       Stream.new(pointer)
@@ -322,24 +444,61 @@ module Libvirt
 
     def define_domain(xml, options_or_flags = nil)
       flags = Util.parse_flags options_or_flags, FFI::Domain.enum_type(:define_flags)
-      pointer = FFI::Domain.virDomainDefineXMLFlags(@conn_ptr, xml, flags)
+      pointer = FFI::Domain.virDomainDefineXMLFlags(@ptr, xml, flags)
       raise Errors::LibError, "Couldn't define domain" if pointer.null?
 
       Domain.new(pointer)
     end
 
-    private
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def create_network(xml)
+      pointer = FFI::Network.virNetworkCreateXML(@ptr, xml)
+      raise Errors::LibError, "Couldn't create network with xml" if pointer.null?
 
-    def set_connection(conn_ptr)
-      @conn_ptr = conn_ptr
+      Network.new(pointer)
     end
 
-    def check_open!
-      raise Errors::LibError, "Connection to #{@uri.inspect} is not open" if @conn_ptr.null?
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def define_network(xml)
+      pointer = FFI::Network.virNetworkDefineXML(@ptr, xml)
+      raise Errors::LibError, "Couldn't define network with xml" if pointer.null?
+
+      Network.new(pointer)
     end
 
-    def dbg(&block)
-      Util.log(:debug, 'Libvirt::Connection', &block)
+    # @param xml [String]
+    # @raise [Libvirt::Errors::LibError]
+    def define_interface(xml)
+      pointer = FFI::Interface.virInterfaceDefineXML(@ptr, xml, 0)
+      raise Errors::LibError, "Couldn't define interface with xml" if pointer.null?
+
+      Interface.new(pointer)
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def begin_interface_change
+      result = FFI::Interface.virInterfaceChangeBegin(@ptr, 0)
+      raise Errors::LibError, "Couldn't begin interface change" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def commit_interface_change
+      result = FFI::Interface.virInterfaceChangeCommit(@ptr, 0)
+      raise Errors::LibError, "Couldn't commit interface change" if result.negative?
+    end
+
+    # @raise [Libvirt::Errors::LibError]
+    def rollback_interface_change
+      result = FFI::Interface.virInterfaceChangeRollback(@ptr, 0)
+      raise Errors::LibError, "Couldn't rollback interface change" if result.negative?
+    end
+
+    private
+
+    def check_open!
+      raise Errors::LibError, "Connection to #{@uri.inspect} is not open" if @ptr.null?
     end
   end
 end