fog-libvirt 0.0.1

data/lib/fog/libvirt/models/compute/util/uri.rb

@@ -0,0 +1,138 @@
+require 'uri'
+require 'cgi'
+
+module Fog
+  module Compute
+    module LibvirtUtil
+      class URI
+        attr_reader :uri
+
+        def initialize(uri)
+          @parsed_uri=::URI.parse(uri)
+          @uri=uri
+          return self
+        end
+
+        # Transport will be part of the scheme
+        # The part after the plus sign
+        # f.i. qemu+ssh
+        def transport
+          scheme=@parsed_uri.scheme
+          return nil if scheme.nil?
+
+          return scheme.split(/\+/)[1]
+        end
+
+        def scheme
+          return @parsed_uri.scheme
+        end
+
+        def driver
+          scheme=@parsed_uri.scheme
+          return nil if scheme.nil?
+
+          return scheme.split(/\+/).first
+        end
+
+        def ssh_enabled?
+          if remote?
+            return transport.include?("ssh")
+          else
+            return false
+          end
+        end
+
+        def remote?
+          return !transport.nil?
+        end
+
+        def user
+          @parsed_uri.user
+        end
+
+        def host
+          @parsed_uri.host
+        end
+
+        def port
+          @parsed_uri.port
+        end
+
+        def password
+          @parsed_uri.password
+        end
+
+        def name
+          value("name")
+        end
+
+        def command
+          value("command")
+        end
+
+        def socket
+          value("socket")
+        end
+
+        def keyfile
+          value("keyfile")
+        end
+
+        def netcat
+          value("netcat")
+        end
+
+        def no_verify?
+          no_verify=value("no_verify")
+          return false if no_verify.nil?
+
+          if no_verify.to_s=="0"
+            return false
+          else
+            return true
+          end
+        end
+
+        def verify?
+          return !no_verify?
+        end
+
+        def no_tty?
+          no_tty=value("no_tty")
+
+          return false if no_tty.nil?
+
+          if no_tty=="0"
+            return false
+          else
+            return true
+          end
+        end
+
+        def tty?
+          return !no_tty?
+        end
+
+        def pkipath
+          value("pkipath")
+        end
+
+        # A libvirt URI allows you to specify extra params
+        # http://libvirt.org/remote.html
+        private
+        def value(name)
+          unless @parsed_uri.query.nil?
+            params=CGI.parse(@parsed_uri.query)
+            if params.key?(name)
+              return params[name].first
+            else
+              return nil
+            end
+          else
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/models/compute/util/util.rb

@@ -0,0 +1,32 @@
+require 'nokogiri'
+require 'erb'
+require 'ostruct'
+require 'securerandom'
+
+module Fog
+  module Compute
+    module LibvirtUtil
+      def xml_element(xml, path, attribute=nil)
+        xml = Nokogiri::XML(xml)
+        attribute.nil? ? (xml/path).first.text : (xml/path).first[attribute.to_sym]
+      end
+
+      def xml_elements(xml, path, attribute=nil)
+         xml = Nokogiri::XML(xml)
+         attribute.nil? ? (xml/path).map : (xml/path).map{|element| element[attribute.to_sym]}
+      end
+
+      def to_xml template_name = nil
+        # figure out our ERB template filename
+        erb = template_name || self.class.to_s.split("::").last.downcase
+        path     = File.join(File.dirname(__FILE__), "..", "templates", "#{erb}.xml.erb")
+        template = File.read(path)
+        ERB.new(template, nil, '-').result(binding)
+      end
+
+      def randomized_name
+        "fog-#{(SecureRandom.random_number*10E14).to_i.round}"
+      end
+    end
+  end
+end

data/lib/fog/libvirt/models/compute/volume.rb

@@ -0,0 +1,122 @@
+require 'fog/core/model'
+require 'fog/libvirt/models/compute/util/util'
+
+module Fog
+  module Compute
+    class Libvirt
+      class Volume < Fog::Model
+        attr_reader :xml
+        include Fog::Compute::LibvirtUtil
+
+        identity :id, :aliases => 'key'
+
+        attribute :pool_name
+        attribute :key
+        attribute :name
+        attribute :path
+        attribute :capacity
+        attribute :allocation
+        attribute :format_type
+        attribute :backing_volume
+
+        # Can be created by passing in :xml => "<xml to create volume>"
+        # A volume always belongs to a pool, :pool_name => "<name of pool>"
+        #
+        def initialize(attributes={ })
+          @xml = attributes.delete(:xml)
+          super(defaults.merge(attributes))
+
+          # We need a connection to calculate the pool_name
+          # This is why we do this after super
+          self.pool_name ||= default_pool_name
+        end
+
+        # Takes a pool and either :xml or other settings
+        def save
+          requires :pool_name
+
+          raise Fog::Errors::Error.new('Reserving an existing volume may create a duplicate') if key
+          @xml ||= to_xml
+          self.path = service.create_volume(pool_name, xml).path
+        end
+
+        # Destroy a volume
+        def destroy
+          service.volume_action key, :delete
+        end
+
+        # Wipes a volume , zeroes disk
+        def wipe
+          service.volume_action key, :wipe
+        end
+
+        # Clones this volume to the name provided
+        def clone(name)
+          new_volume      = self.dup
+          new_volume.key  = nil
+          new_volume.name = name
+          new_volume.save
+
+          new_volume.reload
+        end
+
+        def clone_volume(new_name)
+          requires :pool_name
+
+          new_volume      = self.dup
+          new_volume.key  = nil
+          new_volume.name = new_name
+          new_volume.path = service.clone_volume(pool_name, new_volume.to_xml, self.name).path
+
+          new_volume.reload
+        end
+
+        private
+
+        def image_suffix
+          return "img" if format_type == "raw"
+          format_type
+        end
+
+        def randominzed_name
+          "#{super}.#{image_suffix}"
+        end
+
+        # Try to guess the default/first pool of no pool_name was specified
+        def default_pool_name
+          name = "default"
+          return name unless (service.pools.all(:name => name)).empty?
+
+          # we default to the first pool we find.
+          first_pool = service.pools.first
+
+          raise Fog::Errors::Error.new('No storage pools are defined') unless first_pool
+          first_pool.name
+        end
+
+        def defaults
+          {
+            :persistent  => true,
+            :format_type => "raw",
+            :name        => randomized_name,
+            :capacity    => "10G",
+            :allocation  => "1G",
+          }
+        end
+
+        def split_size_unit(text)
+          if text.kind_of? Integer
+            # if text is an integer, match will fail
+            size    = text
+            unit    = 'G'
+          else
+            matcher = text.match(/(\d+)(.+)/)
+            size    = matcher[1]
+            unit    = matcher[2]
+          end
+          [size, unit]
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/models/compute/volumes.rb

@@ -0,0 +1,20 @@
+require 'fog/core/collection'
+require 'fog/libvirt/models/compute/volume'
+
+module Fog
+  module Compute
+    class Libvirt
+      class Volumes < Fog::Collection
+        model Fog::Compute::Libvirt::Volume
+
+        def all(filter = {})
+          load(service.list_volumes(filter))
+        end
+
+        def get(key)
+          self.all(:key => key).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Fog
+  module Compute
+    class Libvirt
+      class Real
+        def clone_volume (pool_name, xml, name)
+          vol = client.lookup_storage_pool_by_name(pool_name).lookup_volume_by_name(name)
+          client.lookup_storage_pool_by_name(pool_name).create_vol_xml_from(xml, vol)
+        end
+      end
+
+      class Mock
+        def clone_volume(pool_name, xml, name)
+          Fog::Compute::Libvirt::Volume.new({:pool_name => pool_name, :xml => xml})
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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

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

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

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