fog-libvirt 0.0.1

data/lib/fog/libvirt/requests/compute/list_pool_volumes.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def list_pool_volumes(uuid)
+          pool = client.lookup_storage_pool_by_uuid uuid
+          pool.list_volumes.map do |volume_name|
+            volume_to_attributes(pool.lookup_volume_by_name(volume_name))
+          end
+        end
+      end
+
+      class Mock
+        def list_pool_volumes(uuid)
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/list_pools.rb

@@ -0,0 +1,71 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def list_pools(filter = { })
+          data=[]
+          if filter.key?(:name)
+            data << find_pool_by_name(filter[:name])
+          elsif filter.key?(:uuid)
+            data << find_pool_by_uuid(filter[:uuid])
+          else
+            (client.list_storage_pools + client.list_defined_storage_pools).each do |name|
+              data << find_pool_by_name(name)
+            end
+          end
+          data.compact
+        end
+
+        private
+        def pool_to_attributes(pool)
+          states=[:inactive, :building, :running, :degrated, :inaccessible]
+          {
+            :uuid           => pool.uuid,
+            :persistent     => pool.persistent?,
+            :autostart      => pool.autostart?,
+            :active         => pool.active?,
+            :name           => pool.name,
+            :allocation     => pool.info.allocation,
+            :capacity       => pool.info.capacity,
+            :num_of_volumes => pool.num_of_volumes,
+            :state          => states[pool.info.state]
+          }
+        end
+
+        def find_pool_by_name name
+          pool_to_attributes(client.lookup_storage_pool_by_name(name))
+        rescue ::Libvirt::RetrieveError
+          nil
+        end
+
+        def find_pool_by_uuid uuid
+          pool_to_attributes(client.lookup_storage_pool_by_uuid(uuid))
+        rescue ::Libvirt::RetrieveError
+          nil
+        end
+      end
+
+      class Mock
+        def list_pools(filter = { })
+          pool1 = mock_pool 'pool1'
+          pool2 = mock_pool 'pool1'
+          [pool1, pool2]
+        end
+
+        def mock_pool name
+          {
+              :uuid           => 'pool.uuid',
+              :persistent     => true,
+              :autostart      => true,
+              :active         => true,
+              :name           => name,
+              :allocation     => 123456789,
+              :capacity       => 123456789,
+              :num_of_volumes => 3,
+              :state          => :running
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/list_volumes.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def list_volumes(filter = { })
+          data = []
+          if filter.keys.empty?
+            raw_volumes do |pool|
+              pool.list_volumes.each do |volume_name|
+                data << volume_to_attributes(pool.lookup_volume_by_name(volume_name))
+              end
+            end
+          else
+            return [get_volume(filter)]
+          end
+          data.compact
+        end
+
+        private
+
+        def volume_to_attributes(vol)
+          format_type = xml_element(vol.xml_desc, "/volume/target/format", "type") rescue nil # not all volumes have types, e.g. LVM
+          return nil if format_type == "dir"
+
+          {
+            :pool_name   => vol.pool.name,
+            :key         => vol.key,
+            :id          => vol.key,
+            :path        => vol.path,
+            :name        => vol.name,
+            :format_type => format_type,
+            :allocation  => bytes_to_gb(vol.info.allocation),
+            :capacity    => bytes_to_gb(vol.info.capacity),
+          }
+        end
+
+        def bytes_to_gb bytes
+          bytes / 1024**3
+        end
+
+        def raw_volumes
+          client.list_storage_pools.each do |pool_name|
+            pool = client.lookup_storage_pool_by_name(pool_name)
+            yield(pool)
+          end
+        end
+
+        def get_volume filter = { }, raw = false
+          raw_volumes do |pool|
+            vol = case filter.keys.first
+                    when :name
+                      pool.lookup_volume_by_name(filter[:name]) rescue nil
+                    when :key
+                      pool.lookup_volume_by_key(filter[:key]) rescue nil
+                    when :path
+                      pool.lookup_volume_by_path(filter[:path]) rescue nil
+                  end
+            if vol
+              return raw ? vol : volume_to_attributes(vol)
+            end
+          end
+          { }
+        end
+      end
+
+      class Mock
+        def list_volumes(filters={ })
+          vol1 = mock_volume 'vol1'
+          vol2 = mock_volume 'vol2'
+          [vol1, vol2]
+        end
+
+        def mock_volume name
+          {
+              :pool_name   => 'vol.pool.name',
+              :key         => 'vol.key',
+              :id          => 'vol.key',
+              :path        => 'vol.path',
+              :name        => name,
+              :format_type => 'raw',
+              :allocation  => 123,
+              :capacity    => 123,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/mock_files/domain.xml

@@ -0,0 +1,40 @@
+<domain type='kvm'>
+ <name>fog-449765558356062</name>
+ <memory>262144</memory>
+ <vcpu>1</vcpu>
+ <os>
+  <type arch='x86_64'>hvm</type>
+  <boot dev='hd'/>
+  <boot dev='cdrom'/>
+  <boot dev='network'/>
+ </os>
+ <features>
+   <acpi/>
+   <apic/>
+   <pae/>
+ </features>
+ <clock offset='utc'/>
+ <devices>
+  <interface type='network'>
+    <mac address="aa:bb:cc:dd:ee:ff" />
+    <source network='net1' />
+    <model type='virtio'/>
+  </interface>
+  <serial type='pty'>
+   <target port='0'/>
+  </serial>
+  <console type='pty'>
+    <target port='0'/>
+  </console>
+  <input type='mouse' bus='ps2'/>
+  <graphics type='vnc' port='-1' autoport='yes'/>
+  <video>
+   <model type='cirrus' vram='9216' heads='1'/>
+  </video>
+  <disk type='file' device='disk'>
+   <driver name='qemu' type='raw'/>
+   <source file='path/to/disk'/>
+   <target dev='vda' bus='virtio'/>
+  </disk>
+ </devices>
+</domain>

data/lib/fog/libvirt/requests/compute/pool_action.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def pool_action(uuid, action)
+          pool = client.lookup_storage_pool_by_uuid uuid
+          pool.send(action)
+          true
+        end
+      end
+
+      class Mock
+        def pool_action(uuid, action)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/update_display.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def update_display(options = { })
+          raise ArgumentError, "uuid is a required parameter" unless options.key? :uuid
+          display          = { }
+          display[:type]   = options[:type] || 'vnc'
+          display[:port]   = (options[:port] || -1).to_s
+          display[:listen] = options[:listen].to_s   if options[:listen]
+          display[:passwd] = options[:password].to_s if options[:password]
+          display[:autoport] = 'yes' if display[:port] == '-1'
+
+          builder = Nokogiri::XML::Builder.new { graphics_ (display) }
+          xml     = Nokogiri::XML(builder.to_xml).root.to_s
+
+          client.lookup_domain_by_uuid(options[:uuid]).update_device(xml, 0)
+          # if we got no exceptions, then we're good'
+          true
+        end
+      end
+
+      class Mock
+        def update_display(options = { })
+          raise ArgumentError, "uuid is a required parameter" unless options.key? :uuid
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/vm_action.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def vm_action(uuid, action)
+          domain = client.lookup_domain_by_uuid(uuid)
+          domain.send(action)
+          true
+        end
+      end
+
+      class Mock
+        def vm_action(uuid, action)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/requests/compute/volume_action.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def volume_action(key, action, options={})
+          get_volume({:key => key}, true).send(action)
+          true
+        end
+      end
+
+      class Mock
+        def volume_action(action, options={})
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/version.rb

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

data/lib/fog/libvirt.rb

@@ -0,0 +1,18 @@
+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
+
+    module Compute
+      autoload :Libvirt, File.expand_path('../libvirt/compute', __FILE__)
+    end
+
+    service(:compute, 'Compute')
+  end
+end

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,98 @@
+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
+  class Tests
+    # 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]
+    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,110 @@
+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
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+  end
+end

data/tests/libvirt/compute_tests.rb

@@ -0,0 +1,17 @@
+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 list_domains
+        list_interfaces list_networks list_pools list_pool_volumes list_volumes pool_action vm_action volume_action }.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::Compute::Libvirt::Interface') { interface.kind_of? Fog::Compute::Libvirt::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::Compute::Libvirt::Interfaces') { interfaces.kind_of? Fog::Compute::Libvirt::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,27 @@
+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' }
+    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::Compute::Libvirt::Network') { network.kind_of? Fog::Compute::Libvirt::Network }
+  end
+
+end