fog 1.29.0 → 1.30.0

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

@@ -1,17 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def create_domain(xml)
-          client.create_domain_xml(xml)
-        end
-      end
-
-      class Mock
-        def create_domain(xml)
-          ::Libvirt::Domain.new()
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def create_volume(pool_name, xml)
-          client.lookup_storage_pool_by_name(pool_name).create_vol_xml(xml)
-        end
-      end
-
-      class Mock
-        def create_volume(pool_name, xml)
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def define_domain(xml)
-          client.define_domain_xml(xml)
-        end
-      end
-
-      class Mock
-        def define_domain(xml)
-          ::Libvirt::Domain.new()
-        end
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def define_pool(xml)
-          client.define_storage_pool_xml(xml)
-        end
-      end
-
-      class Mock
-        def define_pool(xml)
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        #shutdown the interface
-        def destroy_interface(uuid)
-          client.lookup_interface_by_uuid(uuid).destroy
-        end
-      end
-
-      class Mock
-        def destroy_interface(uuid)
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      class Real
-        def destroy_network(uuid)
-          client.lookup_network_by_uuid(uuid).destroy
-        end
-      end
-
-      class Mock
-        def destroy_network(uuid)
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      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/list_domains.rb

@@ -1,105 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      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 << client.lookup_domain_by_name(name) } unless filter[:defined] == false
-            client.list_domains.each { |id| data << client.lookup_domain_by_id(id) } unless filter[:active] == false
-          end
-          data.compact.map { |d| domain_to_attributes d }
-        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
-          xml_elements(xml, "domain/devices/disk/source", "file")
-        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)
-          {
-            :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]
-          }
-        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

@@ -1,57 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      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

@@ -1,55 +0,0 @@
-module Fog
-  module Compute
-    class Libvirt
-      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
-
-        def network_to_attributes(net)
-          return if net.nil?
-          {
-            :uuid        => net.uuid,
-            :name        => net.name,
-            :bridge_name => net.bridge_name
-          }
-        end
-      end
-
-      class Mock
-        def list_networks(filters={ })
-          net1 = mock_network 'net1'
-          net2 = mock_network 'net2'
-          [net1, net2]
-        end
-
-        def mock_network name
-          {
-              :uuid        => 'net.uuid',
-              :name        => name,
-              :bridge_name => 'net.bridge_name'
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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