fog-libvirt-csem 0.9.0

data/lib/fog/libvirt/version.rb

@@ -0,0 +1,5 @@
+module Fog
+  module Libvirt
+    VERSION = '0.9.0'
+  end
+end

data/lib/fog/libvirt.rb

@@ -0,0 +1,16 @@
+require 'fog/core'
+require 'fog/xml'
+require 'fog/json'
+require 'libvirt'
+
+require File.expand_path('../libvirt/version', __FILE__)
+
+module Fog
+  module Libvirt
+    extend Fog::Provider
+
+    autoload :Compute, File.expand_path('../libvirt/compute', __FILE__)
+
+    service(:compute, 'Compute')
+  end
+end

data/minitests/server/server_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class ServerTest < Minitest::Test
+  def setup
+    @compute = Fog::Compute[:libvirt]
+    @server = @compute.servers.new(:name => "test")
+  end
+
+  def test_addresses_calls_compat_version_for_no_dhcp_leases_support
+    network = Libvirt::Network.new
+    @compute.expects(:networks).returns([network])
+    network.expects(:dhcp_leases).raises(NoMethodError)
+    @server.expects(:addresses_ip_command).returns(true)
+
+    @server.send(:addresses)
+  end
+
+  def test_addresses_calls_compat_version_for_older_libvirt
+    network = Libvirt::Network.new
+    @compute.expects(:libversion).returns(1002007)
+    @compute.expects(:networks).returns([network])
+    network.expects(:dhcp_leases).returns(true)
+    @server.expects(:addresses_ip_command).returns(true)
+
+    @server.send(:addresses)
+  end
+
+  def test_addresses_calls_compat_version_for_newer_libvirt
+    network = Libvirt::Network.new
+    @compute.expects(:libversion).returns(1002008)
+    @compute.expects(:networks).returns([network])
+    network.expects(:dhcp_leases).returns(true)
+    @server.expects(:addresses_dhcp).returns(true)
+
+    @server.send(:addresses)
+  end
+
+  def test_ssh_ip_command_success
+    fog_ssh = MiniTest::Mock.new
+    result = MiniTest::Mock.new
+    result.expect(:status, 0)
+    result.expect(:stdout, "any_ip")
+    fog_ssh.expect(:run, [result], [String])
+    uri = ::Fog::Libvirt::Util::URI.new('qemu+ssh://localhost:22?keyfile=nofile')
+    Fog::SSH.stub(:new, fog_ssh) do
+      @server.send(:ssh_ip_command, "test command", uri)
+    end
+    fog_ssh.verify
+  end
+
+  def test_local_ip_command_success
+    proc_info = MiniTest::Mock.new
+    proc_info.expect(:each_line, "127.0.0.1")
+    proc_info.expect(:pid, 0)
+    status = MiniTest::Mock.new
+    status.expect(:exitstatus, 0)
+    Process.stubs(:waitpid2).returns([0, status])
+    IO.stub(:popen, true, proc_info) do
+      @server.send(:local_ip_command, "test command")
+    end
+    proc_info.verify
+    status.verify
+  end
+end

data/minitests/server/user_data_iso_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class UserDataIsoTest < Minitest::Test
+  def setup
+    @compute = Fog::Compute[:libvirt]
+    @server = @compute.servers.new(:name => "test")
+    @test_data = "test data"
+  end
+
+  def test_contains_meta_data_file
+    @server.stubs(:system).returns(true)
+    in_a_temp_dir do |d|
+      @server.generate_config_iso_in_dir(d, @test_data) {|iso| assert File.exist?(File.join(d, 'meta-data')) }
+    end
+  end
+
+  def test_contains_user_data_file
+    @server.stubs(:system).returns(true)
+    in_a_temp_dir do |d|
+      @server.generate_config_iso_in_dir(d, @test_data) do |iso|
+        assert File.exist?(File.join(d, 'user-data'))
+        assert_equal @test_data,  File.read(File.join(d, 'user-data'))
+      end
+    end
+  end
+
+  def test_iso_is_generated
+    in_a_temp_dir do |d|
+      @server.expects(:system).with(regexp_matches(/^genisoimage/)).returns(true)
+      @server.generate_config_iso_in_dir(d, @test_data) {|iso| }
+    end
+  end
+
+  def test_volume_is_created_during_user_data_iso_generation
+    @server.stubs(:system).returns(true)
+    Fog::Libvirt::Compute::Volumes.any_instance.expects(:create).
+        with(has_entries(:name => @server.cloud_init_volume_name)).
+        returns(@compute.volumes.new)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
+
+    @server.create_user_data_iso
+  end
+
+  def test_volume_is_uploaded_during_user_data_iso_generation
+    @server.stubs(:system).returns(true)
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
+    Fog::Libvirt::Compute::Volume.any_instance.expects(:upload_image).returns(true)
+
+    @server.create_user_data_iso
+  end
+
+  def test_iso_file_is_set_during_user_data_iso_generation
+    @server.stubs(:system).returns(true)
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(@compute.volumes.new)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
+
+    @server.create_user_data_iso
+    assert_equal @server.cloud_init_volume_name, @server.iso_file
+  end
+
+  def test_iso_dir_is_set_during_user_data_iso_generation
+    @server.stubs(:system).returns(true)
+    volume = @compute.volumes.new
+    volume.stubs(:path).returns("/srv/libvirt/#{@server.cloud_init_volume_name}")
+    Fog::Libvirt::Compute::Volumes.any_instance.stubs(:create).returns(volume)
+    Fog::Libvirt::Compute::Volume.any_instance.stubs(:upload_image)
+
+    @server.create_user_data_iso
+    assert_equal '/srv/libvirt', @server.iso_dir
+  end
+
+  def in_a_temp_dir
+    Dir.mktmpdir('test-dir') do |d|
+      yield d
+    end
+  end
+end

data/minitests/test_helper.rb

@@ -0,0 +1,18 @@
+require 'minitest/autorun'
+require 'mocha/minitest'
+require 'fileutils'
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+logdir = File.join(File.dirname(__FILE__), '..', 'logs')
+FileUtils.mkdir_p(logdir) unless File.exist?(logdir)
+
+ENV['TMPDIR'] = 'test/tmp'
+FileUtils.rm_f Dir.glob 'test/tmp/*.tmp'
+
+require 'fog/libvirt'
+
+Fog.mock!
+Fog.credentials = {
+    :libvirt_uri => 'qemu://libvirt/system',
+}.merge(Fog.credentials)

data/tests/helper.rb

@@ -0,0 +1,17 @@
+ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
+ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+
+require 'fog/libvirt'
+
+Excon.defaults.merge!(debug_request: true, debug_response: true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+if Fog.mocking?
+  FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
+  Fog.timeout = 2000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+else
+  FOG_TESTING_TIMEOUT = Fog.timeout
+end

data/tests/helpers/formats_helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'fog/schema/data_validator'
+
+# format related hackery
+# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
+# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
+module Fog
+  module Boolean; end
+  module Nullable
+    module Boolean; end
+    module Integer; end
+    module String; end
+    module Time; end
+    module Float; end
+    module Hash; end
+    module Array; end
+  end
+end
+[FalseClass, TrueClass].each { |klass| klass.send(:include, Fog::Boolean) }
+[FalseClass, TrueClass, NilClass, Fog::Boolean].each { |klass| klass.send(:include, Fog::Nullable::Boolean) }
+[NilClass, String].each { |klass| klass.send(:include, Fog::Nullable::String) }
+[NilClass, Time].each { |klass| klass.send(:include, Fog::Nullable::Time) }
+[Integer, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Integer) }
+[Float, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Float) }
+[Hash, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Hash) }
+[Array, NilClass].each { |klass| klass.send(:include, Fog::Nullable::Array) }
+
+module Shindo
+  # Generates a Shindo test that compares a hash schema to the result
+  # of the passed in block returning true if they match.
+  #
+  # The schema that is passed in is a Hash or Array of hashes that
+  # have Classes in place of values. When checking the schema the
+  # value should match the Class.
+  #
+  # Strict mode will fail if the data has additional keys. Setting
+  # +strict+ to +false+ will allow additional keys to appear.
+  #
+  # @param [Hash] schema A Hash schema
+  # @param [Hash] options Options to change validation rules
+  # @option options [Boolean] :allow_extra_keys
+  #     If +true+ does not fail when keys are in the data that are
+  #     not specified in the schema. This allows new values to
+  #     appear in API output without breaking the check.
+  # @option options [Boolean] :allow_optional_rules
+  #     If +true+ does not fail if extra keys are in the schema
+  #     that do not match the data. Not recommended!
+  # @yield Data to check with schema
+  #
+  # @example Using in a test
+  #     Shindo.tests("comparing welcome data against schema") do
+  #       data = {:welcome => "Hello" }
+  #       data_matches_schema(:welcome => String) { data }
+  #     end
+  #
+  #     comparing welcome data against schema
+  #     + data matches schema
+  #
+  # @example Example schema
+  #     {
+  #       "id" => String,
+  #       "ram" => Integer,
+  #       "disks" => [
+  #         {
+  #           "size" => Float
+  #         }
+  #       ],
+  #       "dns_name" => Fog::Nullable::String,
+  #       "active" => Fog::Boolean,
+  #       "created" => DateTime
+  #     }
+  #
+  # @return [Boolean]
+  class Tests
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = { allow_extra_keys: false, allow_optional_rules: true }
+        else
+          options = { allow_extra_keys: true, allow_optional_rules: true }
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('test_helper', 'meta') do
+
+  tests('comparing welcome data against schema') do
+    data = { welcome: 'Hello' }
+    data_matches_schema(welcome: String) { data }
+  end
+
+  tests('#data_matches_schema') do
+    tests('when value matches schema expectation') do
+      data_matches_schema('key' => String) { { 'key' => 'Value' } }
+    end
+
+    tests('when values within an array all match schema expectation') do
+      data_matches_schema('key' => [Integer]) { { 'key' => [1, 2] } }
+    end
+
+    tests('when nested values match schema expectation') do
+      data_matches_schema('key' => { nested_key: String }) { { 'key' => { nested_key: 'Value' } } }
+    end
+
+    tests('when collection of values all match schema expectation') do
+      data_matches_schema([{ 'key' => String }]) { [{ 'key' => 'Value' }, { 'key' => 'Value' }] }
+    end
+
+    tests('when collection is empty although schema covers optional members') do
+      data_matches_schema([{ 'key' => String }], allow_optional_rules: true) { [] }
+    end
+
+    tests('when additional keys are passed and not strict') do
+      data_matches_schema({ 'key' => String }, allow_extra_keys: true) { { 'key' => 'Value', extra: 'Bonus' } }
+    end
+
+    tests('when value is nil and schema expects NilClass') do
+      data_matches_schema('key' => NilClass) { { 'key' => nil } }
+    end
+
+    tests('when value and schema match as hashes') do
+      data_matches_schema({}) { {} }
+    end
+
+    tests('when value and schema match as arrays') do
+      data_matches_schema([]) { [] }
+    end
+
+    tests('when value is a Time') do
+      data_matches_schema('time' => Time) { { 'time' => Time.now } }
+    end
+
+    tests('when key is missing but value should be NilClass (#1477)') do
+      data_matches_schema({ 'key' => NilClass }, allow_optional_rules: true) { {} }
+    end
+
+    tests('when key is missing but value is nullable (#1477)') do
+      data_matches_schema({ 'key' => Fog::Nullable::String }, allow_optional_rules: true) { {} }
+    end
+  end
+
+  tests('#formats backwards compatible changes') do
+    tests('when value matches schema expectation') do
+      formats('key' => String) { { 'key' => 'Value' } }
+    end
+
+    tests('when values within an array all match schema expectation') do
+      formats('key' => [Integer]) { { 'key' => [1, 2] } }
+    end
+
+    tests('when nested values match schema expectation') do
+      formats('key' => { nested_key: String }) { { 'key' => { nested_key: 'Value' } } }
+    end
+
+    tests('when collection of values all match schema expectation') do
+      formats([{ 'key' => String }]) { [{ 'key' => 'Value' }, { 'key' => 'Value' }] }
+    end
+
+    tests('when collection is empty although schema covers optional members') do
+      formats([{ 'key' => String }]) { [] }
+    end
+
+    tests('when additional keys are passed and not strict') do
+      formats({ 'key' => String }, false) { { 'key' => 'Value', :extra => 'Bonus' } }
+    end
+
+    tests('when value is nil and schema expects NilClass') do
+      formats('key' => NilClass) { { 'key' => nil } }
+    end
+
+    tests('when value and schema match as hashes') do
+      formats({}) { {} }
+    end
+
+    tests('when value and schema match as arrays') do
+      formats([]) { [] }
+    end
+
+    tests('when value is a Time') do
+      formats('time' => Time) { { 'time' => Time.now } }
+    end
+
+    tests('when key is missing but value should be NilClass (#1477)') do
+      formats('key' => NilClass) { {} }
+    end
+
+    tests('when key is missing but value is nullable (#1477)') do
+      formats('key' => Fog::Nullable::String) { {} }
+    end
+  end
+end

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,14 @@
+# Use so you can run in mock mode from the command line
+#
+# FOG_MOCK=true fog
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+# if in mocked mode, fill in some fake credentials for us
+if Fog.mock?
+  Fog.credentials = {
+    libvirt_uri:                       'qemu://libvirt/system',
+  }.merge(Fog.credentials)
+end

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,9 @@
+module Shindo
+  class Tests
+    def succeeds(&block)
+      test('succeeds') do
+        !instance_eval(&Proc.new(&block)).nil?
+      end
+    end
+  end
+end

data/tests/libvirt/compute_tests.rb

@@ -0,0 +1,19 @@
+Shindo.tests('Fog::Compute[:libvirt]', ['libvirt']) do
+
+  compute = Fog::Compute[:libvirt]
+
+  tests("Compute collections") do
+    %w{ servers interfaces networks nics nodes pools volumes}.each do |collection|
+      test("it should respond to #{collection}") { compute.respond_to? collection }
+    end
+  end
+
+  tests("Compute requests") do
+    %w{ create_domain create_volume define_domain define_pool destroy_interface destroy_network get_node_info
+        update_autostart list_domains
+        list_interfaces list_networks list_pools list_pool_volumes list_volumes pool_action vm_action volume_action
+        dhcp_leases }.each do |request|
+      test("it should respond to #{request}") { compute.respond_to? request }
+    end
+  end
+end

data/tests/libvirt/models/compute/interface_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:libvirt] | interface model', ['libvirt']) do
+
+  interfaces = Fog::Compute[:libvirt].interfaces
+  interface = interfaces.last
+
+  tests('The interface model should') do
+    tests('have the action') do
+      test('reload') { interface.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = interface.attributes
+      attributes = [ :name, :mac, :active]
+      tests("The interface model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { interface.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Libvirt::Compute::Interface') { interface.kind_of? Fog::Libvirt::Compute::Interface }
+  end
+
+end

data/tests/libvirt/models/compute/interfaces_tests.rb

@@ -0,0 +1,14 @@
+Shindo.tests('Fog::Compute[:libvirt] | interfaces collection', ['libvirt']) do
+
+  interfaces = Fog::Compute[:libvirt].interfaces
+
+  tests('The interfaces collection') do
+    test('should not be empty') { not interfaces.empty? }
+    test('should be a kind of Fog::Libvirt::Compute::Interfaces') { interfaces.kind_of? Fog::Libvirt::Compute::Interfaces }
+    tests('should be able to reload itself').succeeds { interfaces.reload }
+    tests('should be able to get a model') do
+      tests('by instance name').succeeds { interfaces.get interfaces.first.name }
+    end
+  end
+
+end

data/tests/libvirt/models/compute/network_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::Compute[:libvirt] | network model', ['libvirt']) do
+
+  networks = Fog::Compute[:libvirt].networks
+  network = networks.last
+
+  tests('The network model should') do
+    tests('have the action') do
+      test('reload') { network.respond_to? 'reload' }
+      test('dhcp_leases') { network.respond_to? 'dhcp_leases' }
+    end
+    tests('have a dhcp_leases action that') do
+      test('returns an array') { network.dhcp_leases('99:88:77:66:55:44', 0).kind_of? Array }
+    end
+    tests('have attributes') do
+      model_attribute_hash = network.attributes
+      attributes = [ :name, :uuid, :bridge_name]
+      tests("The network model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { network.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Libvirt::Compute::Network') { network.kind_of? Fog::Libvirt::Compute::Network }
+  end
+
+end

data/tests/libvirt/models/compute/networks_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:libvirt] | networks collection', ['libvirt']) do
+
+  networks = Fog::Compute[:libvirt].networks
+
+  tests('The networks collection') do
+    test('should be a kind of Fog::Libvirt::Compute::Networks') { networks.kind_of? Fog::Libvirt::Compute::Networks }
+    tests('should be able to reload itself').succeeds { networks.reload }
+    tests('should be able to get a model') do
+      tests('by instance id').succeeds { networks.get networks.first.uuid }
+    end
+  end
+
+end

data/tests/libvirt/models/compute/nic_tests.rb

@@ -0,0 +1,31 @@
+Shindo.tests('Fog::Compute[:libvirt] | nic model', ['libvirt']) do
+
+  nic = Fog::Compute[:libvirt].servers.all.select{|v| v.name =~ /^fog/}.first.nics.first
+
+  tests('The nic model should') do
+    tests('have the action') do
+      test('reload') { nic.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = nic.attributes
+      attributes = [ :mac,
+        :model,
+        :type,
+        :network,
+        :bridge]
+      tests("The nic model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { nic.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.delete(:bridge)
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Libvirt::Compute::Nic') { nic.kind_of? Fog::Libvirt::Compute::Nic }
+  end
+
+end

data/tests/libvirt/models/compute/nics_tests.rb

@@ -0,0 +1,10 @@
+Shindo.tests('Fog::Compute[:libvirt] | nics collection', ['libvirt']) do
+
+  nics = Fog::Compute[:libvirt].servers.first.nics
+
+  tests('The nics collection') do
+    test('should not be empty') { not nics.empty? }
+    test('should be a kind of Array') { nics.kind_of? Array }
+  end
+
+end

data/tests/libvirt/models/compute/pool_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Fog::Compute[:libvirt] | interface model', ['libvirt']) do
+
+  pools = Fog::Compute[:libvirt].pools
+  pool = pools.last
+
+  tests('The interface model should') do
+    tests('have the action') do
+      test('reload') { pool.respond_to? 'reload' }
+    end
+    tests('have attributes') do
+      model_attribute_hash = pool.attributes
+      attributes = [ :uuid, :name, :persistent, :active, :autostart, :allocation, :capacity, :num_of_volumes, :state]
+      tests("The interface model should respond to") do
+        attributes.each do |attribute|
+          test("#{attribute}") { pool.respond_to? attribute }
+        end
+      end
+      tests("The attributes hash should have key") do
+        attributes.each do |attribute|
+          test("#{attribute}") { model_attribute_hash.key? attribute }
+        end
+      end
+    end
+    test('be a kind of Fog::Libvirt::Compute::Pool') { pool.kind_of? Fog::Libvirt::Compute::Pool }
+  end
+
+end

data/tests/libvirt/models/compute/pools_tests.rb

@@ -0,0 +1,13 @@
+Shindo.tests('Fog::Compute[:libvirt] | pools request', ['libvirt']) do
+
+  pools = Fog::Compute[:libvirt].pools
+
+  tests('The pools collection') do
+      test('should not be empty') { not pools.empty? }
+      test('should be a kind of Fog::Libvirt::Compute::Pools') { pools.kind_of? Fog::Libvirt::Compute::Pools }
+      tests('should be able to reload itself').succeeds { pools.reload }
+      tests('should be able to get a model') do
+        tests('by instance id').succeeds { pools.get pools.first.uuid }
+      end
+    end
+end