fog-libvirt-csem 0.9.0

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

@@ -0,0 +1,37 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def get_node_info
+          node_hash = Hash.new
+          node_info = client.node_get_info
+          [:model, :memory, :cpus, :mhz, :nodes, :sockets, :cores, :threads].each do |param|
+            node_hash[param] = node_info.send(param) rescue nil
+          end
+          [:type, :version, :node_free_memory, :max_vcpus].each do |param|
+            node_hash[param] = client.send(param) rescue nil
+          end
+          node_hash[:uri] = client.uri
+          xml = client.sys_info rescue nil
+          [:uuid, :manufacturer, :product, :serial].each do |attr|
+            node_hash[attr] = node_attr(attr, xml) rescue nil
+          end if xml
+
+          node_hash[:hostname] = client.hostname
+          [node_hash]
+        end
+
+        private
+
+        def node_attr attr, xml
+          xml_element(xml, "sysinfo/system/entry[@name='#{attr}']").strip
+        end
+      end
+
+      class Mock
+        def get_node_info
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def libversion()
+          client.libversion
+        end
+      end
+
+      class Mock
+        def libversion()
+          return 1002009
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def list_domains(filter = { })
+          data=[]
+
+          if filter.key?(:uuid)
+            data << client.lookup_domain_by_uuid(filter[:uuid])
+          elsif filter.key?(:name)
+            data << client.lookup_domain_by_name(filter[:name])
+          else
+            client.list_defined_domains.each { |name| data << catchLibvirtExceptions { client.lookup_domain_by_name(name) } } unless filter[:defined] == false
+            client.list_domains.each { |id| data << catchLibvirtExceptions { client.lookup_domain_by_id(id) } } unless filter[:active] == false
+          end
+          data.compact.map { |d| domain_to_attributes d }.compact
+        end
+
+        # Catch Libvirt exceptions to avoid race conditions involving
+        # concurrent libvirt operations from other processes. For example,
+        # domains being undefined while fog-libvirt is trying to work with
+        # domain lists.
+        def catchLibvirtExceptions
+          yield
+        rescue ::Libvirt::RetrieveError, ::Libvirt::Error
+          nil
+        end
+      end
+
+      module Shared
+        private
+
+        def domain_display xml
+          attrs = {}
+          [:type, :port, :password, :listen].each do |element|
+            attrs[element] = xml_element(xml, "domain/devices/graphics",element.to_s) rescue nil
+          end
+          attrs.reject{|k,v| v.nil? or v == ""}
+        end
+
+        def domain_volumes xml
+          vols_by_file = xml_elements(xml, "domain/devices/disk/source", "file")
+          vols_by_name = xml_elements(xml, "domain/devices/disk/source", "name")
+          vols = []
+          vols_by_file.zip(vols_by_name).each do |by_file,by_name|
+            vols.push(by_file.nil? ? by_name : by_file)
+          end
+          vols
+        end
+
+        def boot_order xml
+          xml_elements(xml, "domain/os/boot", "dev")
+        end
+
+        def domain_interfaces xml
+          ifs = xml_elements(xml, "domain/devices/interface")
+          ifs.map { |i|
+            nics.new({
+              :type    => i['type'],
+              :mac     => (i/'mac').first[:address],
+              :network => ((i/'source').first[:network] rescue nil),
+              :bridge  => ((i/'source').first[:bridge] rescue nil),
+              :model   => ((i/'model').first[:type] rescue nil),
+            }.reject{|k,v| v.nil?})
+          }
+        end
+
+        def domain_to_attributes(dom)
+          states= %w(nostate running blocked paused shutting-down shutoff crashed pmsuspended)
+
+          begin
+            {
+              :id              => dom.uuid,
+              :uuid            => dom.uuid,
+              :name            => dom.name,
+              :max_memory_size => dom.info.max_mem,
+              :cputime         => dom.info.cpu_time,
+              :memory_size     => dom.info.memory,
+              :cpus            => dom.info.nr_virt_cpu,
+              :autostart       => dom.autostart?,
+              :os_type         => dom.os_type,
+              :active          => dom.active?,
+              :display         => domain_display(dom.xml_desc),
+              :boot_order      => boot_order(dom.xml_desc),
+              :nics            => domain_interfaces(dom.xml_desc),
+              :volumes_path    => domain_volumes(dom.xml_desc),
+              :state           => states[dom.info.state]
+            }
+          rescue ::Libvirt::RetrieveError, ::Libvirt::Error
+            # Catch libvirt exceptions to avoid race conditions involving
+            # concurrent libvirt operations (like from another process)
+            return nil
+          end
+        end
+      end
+
+      class Mock
+        def list_domains(filter = { })
+          dom1 = mock_domain 'fog-dom1'
+          dom2 = mock_domain 'fog-dom2'
+          dom3 = mock_domain 'a-fog-dom3'
+          [dom1, dom2, dom3]
+        end
+
+        def mock_domain name
+          xml = read_xml 'domain.xml'
+          {
+              :id              => "dom.uuid",
+              :uuid            => "dom.uuid",
+              :name            => name,
+              :max_memory_size => 8,
+              :cputime         => 7,
+              :memory_size     => 6,
+              :cpus            => 5,
+              :autostart       => false,
+              :os_type         => "RHEL6",
+              :active          => false,
+              :vnc_port        => 5910,
+              :boot_order      => boot_order(xml),
+              :nics            => domain_interfaces(xml),
+              :volumes_path    => domain_volumes(xml),
+              :state           => 'shutoff'
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def list_interfaces(filter = { })
+          data=[]
+          if filter.keys.empty?
+            active_networks = client.list_interfaces rescue []
+            defined_networks = client.list_defined_interfaces rescue []
+            (active_networks + defined_networks).each do |ifname|
+              data << interface_to_attributes(client.lookup_interface_by_name(ifname))
+            end
+          else
+            data = [interface_to_attributes(get_interface_by_filter(filter))]
+          end
+          data.compact
+        end
+
+        private
+        # Retrieve the interface by mac or by name
+        def get_interface_by_filter(filter)
+          case filter.keys.first
+            when :mac
+              client.lookup_interface_by_mac(filter[:mac])
+            when :name
+              client.lookup_interface_by_name(filter[:name])
+          end
+        end
+
+        def interface_to_attributes(net)
+          return if net.nil? || net.name == 'lo'
+          {
+            :mac    => net.mac,
+            :name   => net.name,
+            :active => net.active?
+          }
+        end
+      end
+
+      class Mock
+        def list_interfaces(filters={ })
+          if1 = mock_interface 'if1'
+          if2 = mock_interface 'if2'
+          [if1, if2]
+        end
+
+        def mock_interface name
+          {
+              :mac    => 'aa:bb:cc:dd:ee:ff',
+              :name   => name,
+              :active => true
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def list_networks(filter = { })
+          data=[]
+          if filter.keys.empty?
+            (client.list_networks + client.list_defined_networks).each do |network_name|
+              data << network_to_attributes(client.lookup_network_by_name(network_name))
+            end
+          else
+            data = [network_to_attributes(get_network_by_filter(filter))]
+          end
+          data
+        end
+
+        private
+        # Retrieve the network by uuid or name
+        def get_network_by_filter(filter)
+          case filter.keys.first
+            when :uuid
+              client.lookup_network_by_uuid(filter[:uuid])
+            when :name
+              client.lookup_network_by_name(filter[:name])
+          end
+        end
+
+        # bridge name may not be defined in some networks, we should skip that in such case
+        def network_to_attributes(net)
+          return if net.nil?
+
+          begin
+            bridge_name = net.bridge_name
+          rescue ::Libvirt::Error
+            bridge_name = ''
+          end
+
+          {
+            :uuid        => net.uuid,
+            :name        => net.name,
+            :bridge_name => bridge_name
+          }
+        end
+      end
+
+      class Mock
+        def list_networks(filters={ })
+          [ {
+              :uuid        => 'a29146ea-39b2-412d-8f53-239eef117a32',
+              :name        => 'net1',
+              :bridge_name => 'virbr0'
+            },
+            {
+              :uuid        => 'fbd4ac68-cbea-4f95-86ed-22953fd92384',
+              :name        => 'net2',
+              :bridge_name => 'virbr1'
+            }
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Libvirt
+    class Compute
+      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 Libvirt
+    class Compute
+      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,106 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def list_volumes(filter = { })
+          data = []
+          if filter.keys.empty?
+            raw_volumes do |pool|
+              pool.list_volumes.each do |volume_name|
+                begin
+                  data << volume_to_attributes(pool.lookup_volume_by_name(volume_name))
+                rescue ::Libvirt::RetrieveError
+                  # Catch libvirt exceptions to avoid race conditions involving
+                  # concurrent libvirt operations (like from another process)
+                  next
+                end
+              end
+            end
+          else
+            data << 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"
+
+          begin
+              {
+                :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),
+              }
+          rescue ::Libvirt::RetrieveError, ::Libvirt::Error
+            return nil # If there are issues during stat of volume file
+          end
+        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
+
+          nil
+        end
+      end
+
+      class Mock
+        def list_volumes(filters={ })
+          vol1 = mock_volume 'vol1'
+          vol2 = mock_volume 'vol2'
+          vols = [vol1, vol2]
+
+          if filters.keys.empty?
+            return vols
+          end
+
+          key = filters.keys.first
+          vols.select { |v| v[key] == filters[key] }
+        end
+
+        def mock_volume name
+          {
+              :pool_name   => 'vol.pool.name',
+              :key         => "vol.#{name}", # needs to match id
+              :id          => "vol.#{name}",
+              :path        => "path/to/disk", # used by in mock_files/domain.xml
+              :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 Libvirt
+    class Compute
+      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_autostart.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def update_autostart(uuid, value)
+          domain = client.lookup_domain_by_uuid(uuid)
+          domain.autostart = value
+        end
+      end
+
+      class Mock
+        def update_autostart(uuid, value)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def update_display(options = { })
+          raise ArgumentError, "uuid is a required parameter" unless options.key? :uuid
+
+          domain = client.lookup_domain_by_uuid(options[: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'
+          new_keymap       = options[:keymap] || xml_elements(domain.xml_desc, "graphics", "keymap")[0]
+          display[:keymap] = new_keymap unless new_keymap.nil?
+
+          builder = Nokogiri::XML::Builder.new { graphics_ (display) }
+          xml     = Nokogiri::XML(builder.to_xml).root.to_s
+
+          domain.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/upload_volume.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def upload_volume(pool_name, volume_name, file_path)
+          volume = client.lookup_storage_pool_by_name(pool_name).lookup_volume_by_name(volume_name)
+          stream = client.stream
+
+          image_file = File.open(file_path, "rb")
+          volume.upload(stream, 0, image_file.size)
+          stream.sendall do |_opaque, n|
+            begin
+              r = image_file.read(n)
+              r ? [r.length, r] : [0, ""]
+            rescue Exception => e
+              [-1, ""]
+            end
+          end
+          stream.finish
+        ensure
+          image_file.close if image_file
+        end
+      end
+
+      class Mock
+        def upload_volume(pool_name, volume_name, file_path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Libvirt
+    class Compute
+      class Real
+        def vm_action(uuid, action, *args)
+          domain = client.lookup_domain_by_uuid(uuid)
+          domain.send(action, *args)
+          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 Libvirt
+    class Compute
+      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