fog 1.1.2 → 1.2.0

data/lib/fog/joyent/requests/compute/list_machines.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Compute
+    class Joyent
+
+      class Mock
+        def list_machines(options={})
+          res = Excon::Response.new
+          res.status = 200
+          res.body = self.data[:machines].values
+          res
+        end
+      end
+
+      class Real
+        def list_machines(options={})
+          request(
+            :path => "/my/machines",
+            :method => "GET",
+            :query => options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/list_packages.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class Joyent
+
+      class Mock
+        def list_packages
+          response = Excon::Response.new()
+          response.status = 200
+          response.body = self.data[:packages].values
+          response
+        end
+      end
+
+      class Real
+        # Lists all the packages available to the authenticated user
+        # ==== Returns
+        # Exon::Response<Array>
+        # * name<~String> The "friendly name for this package
+        # * memory<~Number> How much memory will by available (in Mb)
+        # * disk<~Number> How much disk space will be available (in Gb)
+        # * swap<~Number> How much swap memory will be available (in Mb)
+        # * default<~Boolean> Whether this is the default package in this datacenter"
+        #
+        def list_packages
+          request(
+            :path => "/my/packages",
+            :method => "GET",
+            :expects => 200
+          )
+        end
+      end # Real
+
+    end
+
+  end
+end

data/lib/fog/joyent/requests/compute/reboot_machine.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class Joyent
+      class Real
+        def reboot_machine(id)
+          request(
+            :method => "POST",
+            :query => {"action" => "reboot"},
+            :path => "/my/machines/#{id}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/resize_machine.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class Joyent
+      def resize_machine(id, package)
+        request(
+          :method => "POST",
+          :path => "/my/machines/#{id}",
+          :query => {"action" => "resize", "package" => package}
+        )
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/start_machine.rb

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Joyent
+      class Real
+        def start_machine(id)
+          request(
+            :method => "POST",
+            :path => "/my/machines/#{id}",
+            :query => {"action" => "start"},
+            :expects => 202
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/start_machine_from_snapshot.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class Joyent
+      class Real
+        def start_machine_from_snapshot(machine_id, snapshot_name)
+          request(
+            :method => "POST",
+            :path => "/my/machines/#{machine_id}/snapshots/#{snapshot_name}",
+            :expects => 202
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/stop_machine.rb

@@ -0,0 +1,16 @@
+module Fog
+  module Compute
+    class Joyent
+      class Real
+        def stop_machine(uuid)
+          request(
+            :method => "POST",
+            :path => "/my/machines/#{uuid}",
+            :query => {"action" => "stop"},
+            :expects => 202
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/requests/compute/update_machine_metadata.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class Joyent
+      class Real
+        def update_machine_metadata(machine_id, metadata)
+          request(
+            :method => "POST",
+            :path => "/my/machines/#{machine_id}/metadata",
+            :body => metadata
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/libvirt/compute.rb

@@ -62,7 +62,7 @@ module Fog
             end
 
           rescue ::Libvirt::ConnectionError
-            raise Fog::Errors::Error.new("Error making a connection to libvirt URI #{@uri.uri}:\n#{$!}")
+            raise Fog::Errors::Error.new("Error making a connection to libvirt URI #{uri.uri}:\n#{$!}")
           end
 
         end
@@ -86,10 +86,12 @@ module Fog
               end
             end
           end
-          newuri=uri+append
-          return newuri
+          uri+append
         end
 
+        def respond_to?(method, *)
+          super or @connection.respond_to? method
+        end
 
         # hack to provide 'requests'
         def method_missing(method_sym, *arguments, &block)

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

@@ -48,100 +48,73 @@ module Fog
         # @returns server/domain created
         def initialize(attributes={} )
 
-          self.xml  ||= nil unless attributes[:xml]
-          self.persistent ||=true unless attributes[:persistent]
-          self.cpus ||=1 unless attributes[:cpus]
-          self.memory_size ||=256 *1024 unless attributes[:memory_size]
-          self.name ||="fog-#{SecureRandom.random_number*10E14.to_i.round}" unless attributes[:name]
-
-          self.os_type ||="hvm" unless attributes[:os_type]
-          self.arch ||="x86_64" unless attributes[:arch]
-
-          self.domain_type ||="kvm" unless attributes[:domain_type]
-
-          self.iso_file ||=nil unless attributes[:iso_file]
-          self.iso_dir ||="/var/lib/libvirt/images" unless attributes[:iso_dir]
-
-          self.volume_format_type ||=nil unless attributes[:volume_format_type]
-          self.volume_capacity ||=nil unless attributes[:volume_capacity]
-          self.volume_allocation ||=nil unless attributes[:volume_allocation]
-
-          self.volume_name ||=nil unless attributes[:volume_name]
-          self.volume_pool_name ||=nil unless attributes[:volume_pool_name]
-          self.volume_template_name ||=nil unless attributes[:volume_template_name]
-
-          self.network_interface_type ||="nat" unless attributes[:network_interface_type]
-          self.network_nat_network ||="default" unless attributes[:network_nat_network]
-          self.network_bridge_name ||="br0" unless attributes[:network_bridge_name]
+          # setup all attributes.
+          defaults.merge(attributes).each do |k,v|
+            eval("self.#{k}= v") if self.respond_to?("#{k}=")
+          end
 
           super
         end
 
+        def new?
+          uuid.nil?
+        end
+
         def save
 
-          raise Fog::Errors::Error.new('Resaving an existing server may create a duplicate') if uuid
+          raise Fog::Errors::Error.new('Resaving an existing server may create a duplicate') unless new?
 
           validate_template_options
 
-          xml=xml_from_template if xml.nil?
+          xml ||= xml_from_template
 
           create_or_clone_volume
 
-          xml=xml_from_template
+          xml = xml_from_template
 
           # We either now have xml provided by the user or generated by the template
           begin
-            if !xml.nil?
-              domain=nil
-              if self.persistent
-                domain=connection.raw.define_domain_xml(xml)
-              else
-                domain=connection.raw.create_domain_xml(xml)
-              end
-              self.raw=domain
+            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
         end
 
+        #TODO move all of this to the volume class
         def create_or_clone_volume
 
-          volume_options=Hash.new
+          volume_options = Hash.new
 
-          unless self.volume_name.nil?
-            volume_options[:name]=self.volume_name
-          else
-            extension = self.volume_format_type.nil? ? "img" : self.volume_format_type
-            volume_name = "#{self.name}.#{extension}"
-            volume_options[:name]=volume_name
-          end
+          volume_options[:name] = volume_name || default_volume_name
 
           # Check if a disk template was specified
           unless self.volume_template_name.nil?
 
-            template_volumes=connection.volumes.all(:name => self.volume_template_name)
+            template_volumes = connection.volumes.all(:name => self.volume_template_name)
 
-            raise Fog::Errors::Error.new("Template #{self.volume_template_name} not found") unless template_volumes.length==1
+            raise Fog::Errors::Error.new("Template #{self.volume_template_name} not found") unless template_volumes.empty?
 
-            orig_volume=template_volumes.first
-            self.volume_format_type=orig_volume.format_type unless self.volume_format_type
-            volume=orig_volume.clone("#{volume_options[:name]}")
+            orig_volume = template_volumes.first
+            volume      = orig_volume.clone("#{volume_options[:name]}")
 
+            # 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
+            self.volume_path        = volume.path
 
           else
             # If no template volume was given, let's create our own volume
 
-            volume_options[:format_type]=self.volume_format_type unless self.volume_format_type.nil?
-            volume_options[:capacity]=self.volume_capacity unless self.volume_capacity.nil?
-            volume_options[:allocation]=self.volume_allocation unless self.volume_allocation.nil?
+            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
 
             begin
-              volume=connection.volumes.create(volume_options)
-              self.volume_path=volume.path
-              self.volume_format_type=volume.format_type unless self.volume_format_type
+              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
@@ -158,27 +131,27 @@ module Fog
         def xml_from_template
 
           template_options={
-            :cpus => self.cpus,
-            :memory_size => self.memory_size,
-            :domain_type => self.domain_type,
-            :name => self.name,
-            :iso_file => self.iso_file,
-            :iso_dir => self.iso_dir,
-            :os_type => self.os_type,
-            :arch => self.arch,
-            :volume_path => self.volume_path,
-            :volume_format_type => self.volume_format_type,
-            :network_interface_type => self.network_interface_type,
-            :network_nat_network => self.network_nat_network,
-            :network_bridge_name => self.network_bridge_name
+            :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)
-          result=erb.result(vars_binding)
-          return result
+          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)
+
+          erb.result(vars_binding)
         end
 
         def username
@@ -202,16 +175,13 @@ module Fog
         # In fog a destroy means the remove of a machine
         def destroy(options={ :destroy_volumes => false})
           requires :raw
-          if @raw.active?
-            @raw.destroy
-          end
+          poweroff unless stopped?
+          #TODO: add handling of failure
           @raw.undefine
+
           if options[:destroy_volumes]
-            disk_path = document("domain/devices/disk/source", "file")
             # volumes.all filters do not handle nil keys well
-            (connection.volumes.all(:path => disk_path) rescue []).each do |vol|
-              vol.destroy
-            end
+            connection.volumes.all(:path => disk_path).each { |vol| vol.destroy}
           end
         end
 
@@ -222,7 +192,7 @@ module Fog
 
         # Alias for poweroff
         def halt
-           poweroff
+          poweroff
         end
 
         # In libvirt a destroy means a hard power-off of the domain
@@ -257,7 +227,10 @@ module Fog
                 when 5 then "shutoff"
                 when 6 then "crashed"
                 end
-          return state
+        end
+
+        def stopped?
+          state == "shutoff"
         end
 
         def ready?
@@ -266,20 +239,15 @@ module Fog
 
         def stop
           requires :raw
-
           @raw.shutdown
         end
 
-        #def xml_desc
-          #requires :raw
-          #raw.xml_desc
-        #end
-
         # 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={})
           mac=self.mac
 
@@ -487,21 +455,20 @@ module Fog
         # Retrieves the mac address from parsing the XML of the domain
         def mac
           mac = document("domain/devices/interface/mac", "address")
-          return mac
         end
 
         def vnc_port
-
           port = document("domain/devices/graphics[@type='vnc']", "port")
-          return port
         end
 
+        def disk_path
+          document("domain/devices/disk/source", "file")
+        rescue
+          []
+        end
 
         private
-
-        def raw
-          @raw
-        end
+        attr_reader :raw
 
         def raw=(new_raw)
           @raw = new_raw
@@ -523,13 +490,33 @@ module Fog
           merge_attributes(raw_attributes)
         end
 
+        def randomized_name
+          "fog-#{SecureRandom.random_number*10E14.to_i.round}"
+        end
 
-        # finds a value from xml
-        def document path, attribute=nil
-          xml = REXML::Document.new(self.xml)
-          attribute.nil? ? xml.elements[path].text : xml.elements[path].attributes[attribute]
+        def default_iso_dir
+          "/var/lib/libvirt/images"
         end
 
+        def default_volume_name
+          "#{name}.#{volume_format_type || 'img'}"
+        end
+
+        def defaults
+          {
+            :persistent             => true,
+            :cpus                   => 1,
+            :memory_size            => 256 *1024,
+            :name                   => randomized_name,
+            :os_type                => "hvm",
+            :arch                   => "x86_64",
+            :domain_type            => "kvm",
+            :iso_dir                => default_iso_dir ,
+            :network_interface_type => "nat",
+            :network_nat_network    => "default",
+            :network_bridge_name    => "br0"
+          }
+        end
 
       end