fog 1.3.1 → 1.4.0

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

@@ -9,71 +9,16 @@ module Fog
 
         model Fog::Compute::Libvirt::Server
 
-        def all(filter=nil)
-          data=[]
-          filter={} if filter.nil?
-          include_defined=filter.has_key?(:defined) ? filter[:defined] : true  
-          include_active=filter.has_key?(:active) ? filter[:active] : true  
-
-          unless filter.has_key?(:name) || filter.has_key?(:uuid)
-            if include_defined
-              connection.raw.list_defined_domains.map do |domain|
-                data << { :raw => connection.raw.lookup_domain_by_name(domain) }
-              end
-            end
-            if include_active
-              connection.raw.list_domains.each do |domain|
-                data << { :raw => connection.raw.lookup_domain_by_id(domain) }
-              end
-            end
-          else
-            domain=nil
-            begin
-              domain=self.get_by_name(filter[:name]) if filter.has_key?(:name)
-              domain=self.get_by_uuid(filter[:uuid]) if filter.has_key?(:uuid)
-
-            rescue ::Libvirt::RetrieveError
-              return nil
-            end
-            unless domain.nil?
-              data << { :raw => domain }
-            end
-          end
-
-          load(data)
+        def all(filter={})
+          load(connection.list_domains(filter))
         end
 
         def get(uuid)
-          vm = all(:uuid => uuid)
-          vm.first if vm
-        end
-
-        def bootstrap(new_attributes = {})
-          raise 'Not Implemented'
-          # server = create(new_attributes)
-          # server.start
-          # server.wait_for { ready? }
-          # server.setup(:password => server.password)
-          # server
-        end
-
-        # private #making these internals private screws up reload
-
-        # Retrieve the server by uuid
-        def get_by_uuid(uuid)
-          server=connection.raw.lookup_domain_by_uuid(uuid)
-          return server
-          #          new(:raw => machine)
-        end
-
-        # Retrieve the server by name
-        def get_by_name(name)
-          server=connection.raw.lookup_domain_by_name(name)
-          return server
-          #          new(:raw => machine)
+          data = connection.list_domains(:uuid => uuid)
+          new data.first if data
         end
 
-      end #class
-    end #Class
-  end #module
-end #Module
+      end
+    end
+  end
+end

data/lib/fog/libvirt/models/compute/templates/server.xml.erb

@@ -4,11 +4,9 @@
   <vcpu><%= cpus %></vcpu>
   <os>
     <type arch='<%= arch %>'><%= os_type %></type>
-    <boot dev='hd'/>
-  <% if !iso_file.nil? %>
-
-    <boot dev='cdrom'/>
-  <% end %>
+<% boot_order.each do |dev| -%>
+    <boot dev='<%= dev %>'/>
+<% end -%>
   </os>
   <features>
     <acpi/>
@@ -17,12 +15,15 @@
   </features>
   <clock offset='utc'/>
   <devices>
+<% volumes.each do |vol| -%>
     <disk type='file' device='disk'>
-      <driver name='qemu' type='<%= volume_format_type %>'/>
-      <source file='<%= "#{volume_path}" %>'/>
-      <target dev='vda' bus='virtio'/>
+      <driver name='qemu' type='<%= vol.format_type %>'/>
+      <source file='<%= vol.path %>'/>
+      <%# we need to ensure a unique target dev -%>
+      <target dev='vd<%= ('a'..'z').to_a[volumes.index(vol)] %>' bus='virtio'/>
     </disk>
-  <% if !iso_file.nil? %>
+<% end -%>
+<% if iso_file -%>
     <disk type='file' device='cdrom'>
       <driver name='qemu' type='raw'/>
       <source file='<%= "#{iso_dir}/#{iso_file}" %>'/>
@@ -30,18 +31,13 @@
       <readonly/>
       <address type='drive' controller='0' bus='1' unit='0'/>
     </disk>
-  <% end %>
-    <% if network_interface_type=="bridge" %>
-        <interface type="bridge">
-        <source bridge='<%= network_bridge_name %>'/>
-        <model type='virtio'/>
-      <% end %>
-    <% if network_interface_type=="nat" %>
-        <interface type='network'>
-      <source network='<%= network_nat_network %>'/>
-      <model type='virtio'/>
-    <% end %>
+<% end -%>
+<% nics.each do |nic| -%>
+    <interface type='<%= nic.type %>'>
+      <source <%= nic.type == 'bridge' ? "bridge='#{nic.bridge}'" : "network='#{nic.network}'" %> />
+      <model type='<%= nic.model %>'/>
     </interface>
+<% end -%>
     <serial type='pty'>
       <target port='0'/>
     </serial>
@@ -49,7 +45,7 @@
       <target port='0'/>
     </console>
     <input type='mouse' bus='ps2'/>
-    <graphics type='vnc' port='-1' autoport='yes' keymap='en-us'/>
+     <graphics type='<%= display[:type] %>' port='<%= display[:port] %>' autoport='yes' listen='<%= display[:listen] %>' passwd='<%=display[:password] %>'/>
     <video>
       <model type='cirrus' vram='9216' heads='1'/>
     </video>

data/lib/fog/libvirt/models/compute/templates/volume.xml.erb

@@ -1,7 +1,7 @@
 <volume>
         <name><%= name %></name>
-        <allocation unit="<%= allocation_unit %>"><%= allocation_size %>"></allocation>
-        <capacity unit="<%= capacity_unit %>"><%= capacity_size %>"></capacity>
+        <allocation unit="<%= split_size_unit(allocation)[1] %>"><%= split_size_unit(allocation)[0] %></allocation>
+        <capacity unit="<%= split_size_unit(capacity)[1] %>"><%= split_size_unit(capacity)[0] %></capacity>
         <target>
           <format type="<%= format_type %>"/>
           <permissions>

data/lib/fog/libvirt/models/compute/{uri.rb → util/uri.rb}

@@ -1,7 +1,6 @@
 require 'uri'
 require 'cgi'
 
-
 module Fog
   module Compute
     module LibvirtUtil
@@ -78,7 +77,7 @@ module Fog
         end
 
         def keyfile
-          value("command")
+          value("keyfile")
         end
 
         def netcat

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

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

@@ -1,8 +1,5 @@
 require 'fog/core/model'
-require 'fog/libvirt/models/compute/util'
-require 'rexml/document'
-require 'erb'
-require 'securerandom'
+require 'fog/libvirt/models/compute/util/util'
 
 module Fog
   module Compute
@@ -10,17 +7,15 @@ module Fog
 
       class Volume < Fog::Model
 
+        attr_reader :xml
         include Fog::Compute::LibvirtUtil
 
-        identity :id , :aliases => 'key'
+        identity :id, :aliases => 'key'
 
         attribute :pool_name
-
-        attribute :xml
-
         attribute :key
-        attribute :path
         attribute :name
+        attribute :path
         attribute :capacity
         attribute :allocation
         attribute :format_type
@@ -28,146 +23,83 @@ module Fog
         # Can be created by passing in :xml => "<xml to create volume>"
         # A volume always belongs to a pool, :pool_name => "<name of pool>"
         #
-        # @returns volume created
-        def initialize(attributes={} )
-          self.xml  ||= nil unless attributes[:xml]
-          self.key  = nil
-          self.format_type ||= "raw" unless attributes[:format_type]
-          extension = self.format_type=="raw" ? "img" : self.format_type
-          self.name ||= "fog-#{SecureRandom.random_number*10E14.to_i.round}.#{extension}" unless attributes[:name]
-          self.capacity ||= "10G" unless attributes[:capacity]
-          self.allocation ||= "1G" unless attributes[:allocation]
-          super
-
-          #We need a connection to calculate the poolname
-          #This is why we do this after super
-          self.pool_name  ||= default_pool_name unless attributes[:pool_name]
-        end
+        def initialize(attributes={ })
+          @xml = attributes.delete(:xml)
+          super(defaults.merge(attributes))
 
-        # Try to guess the default/first pool of no pool_name was specificed
-        def default_pool_name
-          default_name="default"
-          default_pool=@connection.pools.all(:name => default_name)
-
-          if default_pool.nil?
-            first_pool=@connection.pools.first
-            if first_pool.nil?
-              raise Fog::Errors::Error.new('We could not find a pool called "default" and there was no other pool defined')
-            else
-              default_name=first_pool.name
-            end
-          end
-          return default_name
+          # 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('Resaving an existing volume may create a duplicate') if key
-
-          xml=xml_from_template if xml.nil?
-
-          begin
-            volume=nil
-            pool=connection.raw.lookup_storage_pool_by_name(pool_name)
-            volume=pool.create_volume_xml(xml)
-            self.raw=volume
-            true
-          rescue
-            raise Fog::Errors::Error.new("Error creating volume: #{$!}")
-            false
-          end
-
-        end
-
-        def split_size_unit(text)
-          matcher=text.match(/(\d+)(.+)/)
-          size=matcher[1]
-          unit=matcher[2]
-          return size , unit
-        end
-
-        # Create a valid xml for the volume based on the template
-        def xml_from_template
-
-          allocation_size,allocation_unit=split_size_unit(self.allocation)
-          capacity_size,capacity_unit=split_size_unit(self.capacity)
-
-          template_options={
-            :name => self.name,
-            :format_type => self.format_type,
-            :allocation_size => allocation_size,
-            :allocation_unit => allocation_unit,
-            :capacity_size => capacity_size,
-            :capacity_unit => capacity_unit
-          }
-
-          # We only want specific variables for ERB
-          vars = ErbBinding.new(template_options)
-          template_path=File.join(File.dirname(__FILE__),"templates","volume.xml.erb")
-          template=File.open(template_path).readlines.join
-          erb = ERB.new(template)
-          vars_binding = vars.send(:get_binding)
-          result=erb.result(vars_binding)
-          return result
+          raise Fog::Errors::Error.new('Reserving an existing volume may create a duplicate') if key
+          @xml ||= to_xml
+          self.path = connection.create_volume(pool_name, xml).path
         end
 
         # Destroy a volume
         def destroy
-          requires :raw
-          raw.delete
-          true
+          connection.volume_action key, :delete
         end
 
         # Wipes a volume , zeroes disk
         def wipe
-          requires :raw
-          raw.wipe
-          true
+          connection.volume_action key, :wipe
         end
 
         # Clones this volume to the name provided
         def clone(name)
-          pool=@raw.pool
-          xml = REXML::Document.new(self.xml)
-          xml.root.elements['/volume/name'].text=name
-          xml.root.elements['/volume/key'].text=name
-          xml.delete_element('/volume/target/path')
-          pool.create_volume_xml_from(xml.to_s,@raw)
-          return connection.volumes.all(:name => name).first
-        end
+          new_volume      = self.dup
+          new_volume.key  = nil
+          new_volume.name = name
+          new_volume.save
 
-        #def xml_desc
-          #requires :raw
-          #raw.xml_desc
-        #end
+          new_volume.reload
+        end
 
         private
-        def raw
-          @raw
+
+        def image_suffix
+          retrun "img" if format_type == "raw"
+          format_type
         end
 
-        def raw=(new_raw)
-          @raw = new_raw
-
-          xml = REXML::Document.new(new_raw.xml_desc)
-          format_type=xml.root.elements['/volume/target/format'].attributes['type']
-
-          raw_attributes = {
-            :key => new_raw.key,
-            :id => new_raw.key,
-            :path => new_raw.path,
-            :name => new_raw.name,
-            :format_type => format_type,
-            :allocation => new_raw.info.allocation,
-            :capacity => new_raw.info.capacity,
-            :xml => new_raw.xml_desc
-          }
+        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 (connection.pools.all(:name => name)).empty?
+
+          # we default to the first pool we find.
+          first_pool = connection.pools.first
+
+          raise Fog::Errors::Error.new('No storage pools are defined') unless first_pool
+          first_pool.name
+        end
 
-          merge_attributes(raw_attributes)
+        def defaults
+          {
+            :persistent  => true,
+            :format_type => "raw",
+            :name        => randomized_name,
+            :capacity    => "10G",
+            :allocation  => "1G",
+          }
         end
 
+        def split_size_unit(text)
+          matcher=text.match(/(\d+)(.+)/)
+          size   = matcher[1]
+          unit   = matcher[2]
+          [size, unit]
+        end
       end
 
     end

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

@@ -9,77 +9,14 @@ module Fog
 
         model Fog::Compute::Libvirt::Volume
 
-        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)
-              pool.list_volumes.each do |volumename|
-                data << { :raw => pool.lookup_volume_by_name(volumename) }
-              end
-            end
-          else
-            volume=nil
-            begin
-              volume=self.get_by_name(filter[:name]) if filter.has_key?(:name)
-              volume=self.get_by_key(filter[:key]) if filter.has_key?(:key)
-              volume=self.get_by_path(filter[:path]) if filter.has_key?(:path)
-              return nil if volume.nil?
-
-            rescue ::Libvirt::RetrieveError
-              return nil
-            end
-            data << { :raw => volume}
-          end
-
-          load(data)
+        def all(filter = {})
+          load(connection.list_volumes(filter))
         end
 
         def get(key)
           self.all(:key => key).first
         end
 
-
-        # Retrieve the volume by name
-        def get_by_name(name)
-          connection.raw.list_storage_pools.each do |poolname|
-            pool=connection.raw.lookup_storage_pool_by_name(poolname)
-            volume=pool.lookup_volume_by_name(name)
-            unless volume.nil?
-              return volume
-            end
-          end
-
-          return nil
-        end
-
-        # Retrieve the volume by key
-        def get_by_key(key)
-          connection.raw.list_storage_pools.each do |poolname|
-            pool=connection.raw.lookup_storage_pool_by_name(poolname)
-            volume=pool.lookup_volume_by_key(key)
-            unless volume.nil?
-              return  volume
-            end
-          end
-
-          return nil
-        end
-
-        # Retrieve the volume by key
-        def get_by_path(path)
-          connection.raw.list_storage_pools.each do |poolname|
-            pool=connection.raw.lookup_storage_pool_by_name(poolname)
-            volume=pool.lookup_volume_by_key(path)
-            unless volume.nil?
-              return volume
-            end
-          end
-
-          return nil
-        end
-
-
       end
 
     end