fog 1.3.1 → 1.4.0

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

@@ -9,52 +9,16 @@ module Fog
 
         model Fog::Compute::Libvirt::Pool
 
-        def all(filter=nil)
-          data=[]
-          if filter.nil?
-            connection.raw.list_storage_pools.each do |poolname|
-              pool=connection.raw.lookup_storage_pool_by_name(poolname)
-              data << { :raw => pool }
-            end
-            connection.raw.list_defined_storage_pools.each do |poolname|
-              data << {
-                :raw => connection.raw.lookup_storage_pool_by_name(poolname)
-              }
-            end
-          else
-            pool=nil
-            begin
-              pool=get_by_uuid(filter[:uuid]) if filter.has_key?(:uuid)
-              pool=get_by_name(filter[:name]) if filter.has_key?(:name)
-            rescue ::Libvirt::RetrieveError
-              return nil
-            end
-            data << { :raw => pool}
-          end
-
-          load(data)
+        def all(filter = {})
+          load(connection.list_pools(filter))
         end
 
         def get(uuid)
           self.all(:uuid => uuid).first
         end
 
-        #private # Making these private, screws up realod
-        # Retrieve the pool by uuid
-        def get_by_uuid(uuid)
-          pool=connection.raw.lookup_storage_pool_by_uuid(uuid)
-          return pool
-        end
-
-        # Retrieve the pool by name
-        def get_by_name(name)
-          pool=connection.raw.lookup_storage_pool_by_name(name)
-          return pool
-          #          new(:raw => pool)
-        end
-
-      end #class
+      end
 
-    end #Class
-  end #module
-end #module
+    end
+  end
+end

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

@@ -1,59 +1,56 @@
-require 'fog/core/model'
-require 'fog/libvirt/models/compute/util'
+require 'fog/compute/models/server'
+require 'fog/libvirt/models/compute/util/util'
 require 'net/ssh/proxy/command'
-require 'rexml/document'
-require 'erb'
-require 'securerandom'
-
 
 module Fog
   module Compute
     class Libvirt
 
-      class Server < Fog::Model
+      class Server < Fog::Compute::Server
 
         include Fog::Compute::LibvirtUtil
+        attr_reader :xml
 
         identity :id, :aliases => 'uuid'
-        attribute :xml
 
         attribute :cpus
         attribute :cputime
         attribute :os_type
         attribute :memory_size
         attribute :max_memory_size
-
         attribute :name
         attribute :arch
         attribute :persistent
         attribute :domain_type
         attribute :uuid
         attribute :autostart
+        attribute :nics
+        attribute :volumes
+        attribute :active
+        attribute :boot_order
+        attribute :display
 
         attribute :state
 
         # The following attributes are only needed when creating a new vm
+        #TODO: Add depreciation warning
         attr_accessor :iso_dir, :iso_file
         attr_accessor :network_interface_type ,:network_nat_network, :network_bridge_name
         attr_accessor :volume_format_type, :volume_allocation,:volume_capacity, :volume_name, :volume_pool_name, :volume_template_name, :volume_path
-
         attr_accessor :password
         attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
 
         # Can be created by passing in :xml => "<xml to create domain/server>"
         # or by providing :template_options => {
         #                :name => "", :cpus => 1, :memory_size => 256 , :volume_template
-        #   :}
-        #
-        # @returns server/domain created
-        def initialize(attributes={} )
+        #   }
 
-          # setup all attributes.
-          defaults.merge(attributes).each do |k,v|
-            eval("self.#{k}= v") if self.respond_to?("#{k}=")
-          end
-
-          super
+        def initialize(attributes={} )
+          @xml = attributes.delete(:xml)
+          verify_boot_order(attributes[:boot_order])
+          super defaults.merge(attributes)
+          initialize_nics
+          initialize_volumes
         end
 
         def new?
@@ -61,207 +58,202 @@ module Fog
         end
 
         def save
+          raise Fog::Errors::Error.new('Saving an existing server may create a duplicate') unless new?
+          create_or_clone_volume unless xml or @volumes
+          @xml ||= to_xml
+          self.id = (persistent ? connection.define_domain(xml) : connection.create_domain(xml)).uuid
+          reload
+        rescue => e
+          raise Fog::Errors::Error.new("Error saving the server: #{e}")
+        end
 
-          raise Fog::Errors::Error.new('Resaving an existing server may create a duplicate') unless new?
-
-          validate_template_options
-
-          xml ||= xml_from_template
+        def username
+          @username ||= 'root'
+        end
 
-          create_or_clone_volume
+        def start
+          return true if active?
+          connection.vm_action(uuid, :create)
+          reload
+          true
+        end
 
-          xml = xml_from_template
+        def mac
+          nics.first.mac if nics && nics.first
+        end
 
-          # We either now have xml provided by the user or generated by the template
-          begin
-            if xml
-              self.raw = persistent ? connection.raw.define_domain_xml(xml) : connection.raw.create_domain_xml(xml)
-            end
-          rescue
-            raise Fog::Errors::Error.new("Error saving the server: #{$!}")
-          end
+        def disk_path
+          volumes.first.path if volumes and volumes.first
         end
 
-        #TODO move all of this to the volume class
-        def create_or_clone_volume
+        def destroy(options={ :destroy_volumes => false})
+          poweroff unless stopped?
+          connection.vm_action(uuid, :undefine)
+          volumes.each { |vol| vol.destroy } if options[:destroy_volumes]
+          true
+        end
 
-          volume_options = Hash.new
+        def reboot
+          connection.vm_action(uuid, :reboot)
+        end
 
-          volume_options[:name] = volume_name || default_volume_name
+        def poweroff
+          connection.vm_action(uuid, :destroy)
+        end
 
-          # Check if a disk template was specified
-          unless self.volume_template_name.nil?
+        def shutdown
+          connection.vm_action(uuid, :shutdown)
+        end
 
-            template_volumes = connection.volumes.all(:name => self.volume_template_name)
+        def resume
+          connection.vm_action(uuid, :resume)
+        end
 
-            raise Fog::Errors::Error.new("Template #{self.volume_template_name} not found") unless template_volumes.empty?
+        def suspend
+          connection.vm_action(uuid, :suspend)
+        end
 
-            orig_volume = template_volumes.first
-            volume      = orig_volume.clone("#{volume_options[:name]}")
+        def stopped?
+          state == "shutoff"
+        end
 
-            # if we cloned it, it has the original volume type.
-            self.volume_format_type = orig_volume.format_type
-            # This gets passed to the domain to know the path of the disk
-            self.volume_path        = volume.path
+        def ready?
+          state == "running"
+        end
 
-          else
-            # If no template volume was given, let's create our own volume
+        #alias methods
+        alias :halt    :poweroff
+        alias :stop    :shutdown
+        alias :active? :active
 
-            volume_options[:format_type] = self.volume_format_type if volume_format_type
-            volume_options[:capacity]    = self.volume_capacity    if volume_capacity
-            volume_options[:allocation]  = self.volume_allocation  if volume_allocation
+        def volumes
+          # lazy loading of volumes
+          @volumes ||= (@volumes_path || []).map{|path| connection.volumes.all(:path => path).first }
+        end
 
-            begin
-              volume                    = connection.volumes.create(volume_options)
-              self.volume_path          = volume.path
-              self.volume_format_type ||= volume.format_type
-            rescue
-              raise Fog::Errors::Error.new("Error creating the volume : #{$!}")
-            end
+        def private_ip_address
+          ip_address(:private)
+        end
 
-          end
+        def public_ip_address
+          ip_address(:public)
         end
 
-        def validate_template_options
-          unless self.network_interface_type.nil?
-            raise Fog::Errors::Error.new("#{self.network_interface_type} is not a supported interface type") unless ["nat", "bridge"].include?(self.network_interface_type)
-          end
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
         end
 
-        def xml_from_template
-
-          template_options={
-            :cpus                   => cpus,
-            :memory_size            => memory_size,
-            :domain_type            => domain_type,
-            :name                   => name,
-            :iso_file               => iso_file,
-            :iso_dir                => iso_dir,
-            :os_type                => os_type,
-            :arch                   => arch,
-            :volume_path            => volume_path,
-            :volume_format_type     => volume_format_type,
-            :network_interface_type => network_interface_type,
-            :network_nat_network    => network_nat_network,
-            :network_bridge_name    => network_bridge_name
-          }
-          vars          = ErbBinding.new(template_options)
-          template_path = File.join(File.dirname(__FILE__),"templates","server.xml.erb")
-          template      = File.open(template_path).readlines.join
-          erb           = ERB.new(template)
-          vars_binding  = vars.send(:get_binding)
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
 
-          erb.result(vars_binding)
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
         end
 
-        def username
-          @username ||= 'root'
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
         end
 
-        def start
-          requires :raw
+        def ssh(commands)
+          requires :public_ip_address, :username
 
-          unless @raw.active?
-            begin
-              @raw.create
-              true
-            rescue
-              false
-            end
-          end
-        end
+          #requires :password, :private_key
+          ssh_options={}
+          ssh_options[:password] = password unless password.nil?
+          ssh_options[:key_data] = [private_key] if private_key
+          ssh_options[:proxy]= ssh_proxy unless ssh_proxy.nil?
 
-        # In libvirt a destroy means a hard power-off of the domain
-        # In fog a destroy means the remove of a machine
-        def destroy(options={ :destroy_volumes => false})
-          requires :raw
-          poweroff unless stopped?
-          #TODO: add handling of failure
-          @raw.undefine
+          Fog::SSH.new(public_ip_address, @username, ssh_options).run(commands)
 
-          if options[:destroy_volumes]
-            # volumes.all filters do not handle nil keys well
-            connection.volumes.all(:path => disk_path).each { |vol| vol.destroy}
-          end
         end
 
-        def reboot
-          requires :raw
-          @raw.reboot
+        def ssh_proxy
+          # if this is a direct connection, we don't need a proxy to be set.
+          return nil unless @connection.uri.ssh_enabled?
+          user_string= connection.uri.user ? "-l #{connection.uri.user}" : ""
+          Net::SSH::Proxy::Command.new("ssh #{user_string} #{connection.uri.host} nc %h %p")
         end
 
-        # Alias for poweroff
-        def halt
-          poweroff
-        end
+        # Transfers a file
+        def scp(local_path, remote_path, upload_options = {})
+          requires :public_ip_address, :username
 
-        # In libvirt a destroy means a hard power-off of the domain
-        # In fog a destroy means the remove of a machine
-        def poweroff
-          requires :raw
-          @raw.destroy
-        end
+          scp_options = {}
+          scp_options[:password] = password unless self.password.nil?
+          scp_options[:key_data] = [private_key] if self.private_key
+          scp_options[:proxy]= ssh_proxy unless self.ssh_proxy.nil?
 
-        def shutdown
-          requires :raw
-          @raw.shutdown
+          Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
         end
 
-        def resume
-          requires :raw
-          @raw.resume
-        end
+        # Sets up a new key
+        def setup(credentials = {})
+          requires :public_key, :public_ip_address, :username
 
-        def suspend
-          requires :raw
-          @raw.suspend
-        end
+          credentials[:proxy]= ssh_proxy unless ssh_proxy.nil?
+          credentials[:password] = password unless self.password.nil?
+          credentails[:key_data] = [private_key] if self.private_key
 
-        def to_fog_state(raw_state)
-          state=case raw_state
-                when 0 then "nostate"
-                when 1 then "running"
-                when 2 then "blocked"
-                when 3 then "paused"
-                when 4 then "shutting-down"
-                when 5 then "shutoff"
-                when 6 then "crashed"
-                end
-        end
+          commands = [
+            %{mkdir .ssh},
+            #              %{passwd -l #{username}}, #Not sure if we need this here
+            #              %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json}
+          ]
+          if public_key
+            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+          end
 
-        def stopped?
-          state == "shutoff"
+          # wait for domain to be ready
+          Timeout::timeout(360) do
+            begin
+              Timeout::timeout(8) do
+                Fog::SSH.new(public_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
+              end
+            rescue Errno::ECONNREFUSED
+              sleep(2)
+              retry
+            rescue Net::SSH::AuthenticationFailed, Timeout::Error
+              retry
+            end
+          end
+          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
         end
 
-        def ready?
-          state == "running"
+        def update_display attrs = {}
+          connection.update_display attrs.merge(:uuid => uuid)
+          reload
         end
 
-        def stop
-          requires :raw
-          @raw.shutdown
+        # can't use deprecate method, as the value is part of the display hash
+        def vnc_port
+          Fog::Logger.deprecation("#{self.class} => #vnc_port is deprecated, use #display[:port] instead [light_black](#{caller.first})[/]")
+          display[:port]
         end
 
+        private
+        attr_accessor :volumes_path
+
         # This retrieves the ip address of the mac address
         # It returns an array of public and private ip addresses
         # Currently only one ip address is returned, but in the future this could be multiple
         # if the server has multiple network interface
-        #
-        #TODO: move this into the util class
-        def addresses(options={})
+        def addresses(connection, options={})
           mac=self.mac
 
           # Aug 24 17:34:41 juno arpwatch: new station 10.247.4.137 52:54:00:88:5a:0a eth0.4
           # Aug 24 17:37:19 juno arpwatch: changed ethernet address 10.247.4.137 52:54:00:27:33:00 (52:54:00:88:5a:0a) eth0.4
           # Check if another ip_command string was provided
-          ip_command_global=@connection.ip_command.nil? ? 'grep $mac /var/log/arpwatch.log|sed -e "s/new station//"|sed -e "s/changed ethernet address//g" |sed -e "s/reused old ethernet //" |tail -1 |cut -d ":" -f 4-| cut -d " " -f 3' : @connection.ip_command
+          ip_command_global=connection.ip_command.nil? ? 'grep $mac /var/log/arpwatch.log|sed -e "s/new station//"|sed -e "s/changed ethernet address//g" |sed -e "s/reused old ethernet //" |tail -1 |cut -d ":" -f 4-| cut -d " " -f 3' : connection.ip_command
           ip_command_local=options[:ip_command].nil? ? ip_command_global : options[:ip_command]
 
           ip_command="mac=#{mac}; server_name=#{name}; "+ip_command_local
 
           ip_address=nil
 
-          if @connection.uri.ssh_enabled?
+          if connection.uri.ssh_enabled?
 
             # Retrieve the parts we need from the connection to setup our ssh options
             user=connection.uri.user #could be nil
@@ -275,8 +267,6 @@ module Fog
             ssh_options[:port]=port unless keyfile.nil?
             ssh_options[:paranoid]=true if connection.uri.no_verify?
 
-            # TODO: we need to take the time into account, when IP's are re-allocated, we might be executing
-            # On the wrong host
 
             begin
               result=Fog::SSH.new(host, user, ssh_options).run(ip_command)
@@ -286,8 +276,6 @@ module Fog
               raise Fog::Errors::Error.new("Error authenticating over ssh to host #{host} and user #{user}")
             end
 
-            #TODO: We currently just retrieve the ip address through the ip_command
-            #TODO: We need to check if that ip_address is still valid for that mac-address
 
             # Check for a clean exit code
             if result.first.status == 0
@@ -299,7 +287,7 @@ module Fog
 
           else
             # It's not ssh enabled, so we assume it is
-            if @connection.uri.transport=="tls"
+            if connection.uri.transport=="tls"
               raise Fog::Errors::Error.new("TlS remote transport is not currently supported, only ssh")
             end
 
@@ -333,165 +321,57 @@ module Fog
             # otherwise we return nil
             unless ip_address=~/^(\d{1,3}\.){3}\d{1,3}$/
               raise Fog::Errors::Error.new(
-                "The result of #{ip_command} does not have valid ip-address format\n"+
-                "Result was: #{ip_address}\n"
-            )
+                        "The result of #{ip_command} does not have valid ip-address format\n"+
+                            "Result was: #{ip_address}\n"
+                    )
             end
           end
 
           return { :public => [ip_address], :private => [ip_address]}
         end
 
-        def private_ip_address
-          ip_address(:private)
-        end
-
-        def public_ip_address
-          ip_address(:public)
-        end
-
         def ip_address(key)
-          ips=addresses[key]
-          unless ips.nil?
-            return ips.first
-          else
-            return nil
-          end
-        end
-
-        def private_key_path
-          @private_key_path ||= Fog.credentials[:private_key_path]
-          @private_key_path &&= File.expand_path(@private_key_path)
-        end
-
-        def private_key
-          @private_key ||= private_key_path && File.read(private_key_path)
+          addresses[key].nil? ? nil : addresses[key].first
         end
 
-        def public_key_path
-          @public_key_path ||= Fog.credentials[:public_key_path]
-          @public_key_path &&= File.expand_path(@public_key_path)
-        end
-
-        def public_key
-          @public_key ||= public_key_path && File.read(public_key_path)
-        end
-
-        def ssh(commands)
-          requires :public_ip_address, :username
-
-          #requires :password, :private_key
-          ssh_options={}
-          ssh_options[:password] = password unless password.nil?
-          ssh_options[:key_data] = [private_key] if private_key
-          ssh_options[:proxy]= ssh_proxy unless ssh_proxy.nil?
-
-          Fog::SSH.new(public_ip_address, @username, ssh_options).run(commands)
-
-        end
-
-
-        def ssh_proxy
-          proxy=nil
-          if @connection.uri.ssh_enabled?
-            relay=connection.uri.host
-            user_string=""
-            user_string="-l #{connection.uri.user}" unless connection.uri.user.nil?
-            proxy = Net::SSH::Proxy::Command.new("ssh #{user_string} "+relay+" nc %h %p")
-            return proxy
+        def initialize_nics
+          if nics
+            nics.map! { |nic| nic.is_a?(Hash) ? connection.nics.new(nic) : nic }
           else
-            return nil
-            # This is a direct connection, so we don't need a proxy to be set
+            self.nics = [connection.nics.new({:type => network_interface_type, :bridge => network_bridge_name, :network => network_nat_network})]
           end
         end
 
-        # Transfers a file
-        def scp(local_path, remote_path, upload_options = {})
-          requires :public_ip_address, :username
-
-          scp_options = {}
-          scp_options[:password] = password unless self.password.nil?
-          scp_options[:key_data] = [private_key] if self.private_key
-          scp_options[:proxy]= ssh_proxy unless self.ssh_proxy.nil?
-
-          Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+        def initialize_volumes
+          if attributes[:volumes] && !attributes[:volumes].empty?
+            @volumes = attributes[:volumes].map { |vol| vol.is_a?(Hash) ? connection.volumes.new(vol) : vol }
+          end
         end
 
+        def create_or_clone_volume
+          options = {:name => volume_name || default_volume_name}
+          # Check if a disk template was specified
+          if volume_template_name
+            template_volume = connection.volumes.all(:name => volume_template_name).first
+            raise Fog::Errors::Error.new("Template #{volume_template_name} not found") unless template_volume
+            begin
+              volume = template_volume.clone("#{options[:name]}")
+            rescue => e
+              raise Fog::Errors::Error.new("Error creating the volume : #{e}")
+            end
+          else
+            # If no template volume was given, let's create our own volume
+            options[:format_type] = volume_format_type if volume_format_type
+            options[:capacity]    = volume_capacity    if volume_capacity
+            options[:allocation]  = volume_allocation  if volume_allocation
 
-        # Sets up a new key
-        def setup(credentials = {})
-          requires :public_key, :public_ip_address, :username
-          require 'multi_json'
-
-          credentials[:proxy]= ssh_proxy unless ssh_proxy.nil?
-          credentials[:password] = password unless self.password.nil?
-          credentails[:key_data] = [private_key] if self.private_key
-
-          commands = [
-            %{mkdir .ssh},
-            #              %{passwd -l #{username}}, #Not sure if we need this here
-            #              %{echo "#{MultiJson.encode(attributes)}" >> ~/attributes.json}
-          ]
-          if public_key
-            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
-          end
-
-          # wait for domain to be ready
-          Timeout::timeout(360) do
             begin
-              Timeout::timeout(8) do
-                Fog::SSH.new(public_ip_address, username, credentials.merge(:timeout => 4)).run('pwd')
-              end
-            rescue Errno::ECONNREFUSED
-              sleep(2)
-              retry
-            rescue Net::SSH::AuthenticationFailed, Timeout::Error
-              retry
+              volume = connection.volumes.create(options)
+            rescue => e
+              raise Fog::Errors::Error.new("Error creating the volume : #{e}")
             end
           end
-          Fog::SSH.new(public_ip_address, username, credentials).run(commands)
-        end
-
-        # Retrieves the mac address from parsing the XML of the domain
-        def mac
-          mac = document("domain/devices/interface/mac", "address")
-        end
-
-        def vnc_port
-          port = document("domain/devices/graphics[@type='vnc']", "port")
-        end
-
-        def disk_path
-          document("domain/devices/disk/source", "file")
-        rescue
-          []
-        end
-
-        private
-        attr_reader :raw
-
-        def raw=(new_raw)
-          @raw = new_raw
-
-          raw_attributes = {
-            :id => new_raw.uuid,
-            :uuid => new_raw.uuid,
-            :name => new_raw.name,
-            :max_memory_size => new_raw.info.max_mem,
-            :cputime => new_raw.info.cpu_time,
-            :memory_size => new_raw.info.memory,
-            :vcpus => new_raw.info.nr_virt_cpu,
-            :autostart => new_raw.autostart?,
-            :os_type => new_raw.os_type,
-            :xml => new_raw.xml_desc,
-            :state => self.to_fog_state(new_raw.info.state)
-          }
-
-          merge_attributes(raw_attributes)
-        end
-
-        def randomized_name
-          "fog-#{SecureRandom.random_number*10E14.to_i.round}"
+          @volumes.nil? ? @volumes = [volume] : @volumes << volume
         end
 
         def default_iso_dir
@@ -511,13 +391,31 @@ module Fog
             :os_type                => "hvm",
             :arch                   => "x86_64",
             :domain_type            => "kvm",
-            :iso_dir                => default_iso_dir ,
-            :network_interface_type => "nat",
+            :iso_dir                => default_iso_dir,
+            :network_interface_type => "network",
             :network_nat_network    => "default",
-            :network_bridge_name    => "br0"
+            :network_bridge_name    => "br0",
+            :boot_order             => default_boot_order,
+            :display                => default_display
           }
         end
 
+        def default_boot_order
+          %w[hd cdrom network]
+        end
+
+        def verify_boot_order order = []
+          if order
+            order.each do |b|
+              raise "invalid boot order, possible values are: hd, network and/or cdrom" unless default_boot_order.include?(b)
+            end
+          end
+        end
+
+        def default_display
+          {:port => '-1', :listen => '127.0.0.1', :type => 'vnc', :password => '' }
+        end
+
       end
 
     end