fog 1.10.1 → 1.11.0

data/lib/fog/bin/google.rb

@@ -1,8 +1,10 @@
-class Google < Fog::Bin
+module Google # deviates from other bin stuff to accomodate gem
   class << self
 
     def class_for(key)
       case key
+      when :compute
+        Fog::Compute::Google
       when :storage
         Fog::Storage::Google
       else 
@@ -16,6 +18,9 @@ class Google < Fog::Bin
         when :storage
           Fog::Logger.warning("Google[:storage] is not recommended, use Storage[:google] for portability")
           Fog::Storage.new(:provider => 'Google')
+        when :compute
+          Fog::Logger.warning("Google[:compute] is not recommended, use Compute[:google] for portability")
+          Fog::Compute.new(:provider => 'Google')
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end
@@ -23,9 +28,50 @@ class Google < Fog::Bin
       @@connections[service]
     end
 
+    def account
+      @@connections[:compute].account
+    end
+
     def services
       Fog::Google.services
     end
 
+    # based off of virtual_box.rb
+    def available?
+      # Make sure the gem we use is enabled.
+      availability = if Gem::Specification.respond_to?(:find_all_by_name)
+        !Gem::Specification.find_all_by_name('google-api-client').empty? # newest rubygems
+      else
+        !Gem.source_index.find_name('google-api-client').empty? # legacy
+      end
+
+      # Then make sure we have all of the requirements
+      for service in services
+        begin
+          service = self.class_for(service)
+          availability &&= service.requirements.all? { |requirement| Fog.credentials.include?(requirement) }
+        rescue ArgumentError => e
+          Fog::Logger.warning(e.message)
+          availability = false
+        rescue => e
+          availability = false
+        end
+      end
+
+      if availability
+        for service in services
+          for collection in self.class_for(service).collections
+            unless self.respond_to?(collection)
+              self.class_eval <<-EOS, __FILE__, __LINE__
+                def self.#{collection}
+                  self[:#{service}].#{collection}
+                end
+              EOS
+            end
+          end
+        end
+      end
+      availability
+    end
   end
 end

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

@@ -57,7 +57,9 @@ module Fog
         end
 
         def public_ip_address
-          ips.first
+          if ip = ips.first
+            ip['address']
+          end
         end
 
         def ready?

data/lib/fog/brightbox/compute.rb

@@ -1,6 +1,7 @@
 require 'fog/brightbox'
 require 'fog/compute'
 require 'fog/brightbox/oauth2'
+require 'fog/brightbox/compute/image_selector'
 
 module Fog
   module Compute
@@ -268,13 +269,15 @@ module Fog
 
         # Returns an identifier for the default image for use
         #
-        # Currently tries to find the latest version Ubuntu LTS (i686) widening
-        # up to the latest, official version of Ubuntu available.
+        # Currently tries to find the latest version of Ubuntu (i686) from
+        # Brightbox.
         #
         # Highly recommended that you actually select the image you want to run
         # on your servers yourself!
         #
-        # @return [String, nil]
+        # @return [String] if image is found, returns the identifier
+        # @return [NilClass] if no image is found or an error occurs
+        #
         def default_image
           return @default_image_id unless @default_image_id.nil?
           @default_image_id = Fog.credentials[:brightbox_default_image] || select_default_image
@@ -458,30 +461,12 @@ module Fog
 
         # Queries the API and tries to select the most suitable official Image
         # to use if the user chooses not to select their own.
+        #
+        # @return [String] if image is found, the image's identifier
+        # @return [NilClass] if no image found or an error occured
+        #
         def select_default_image
-          return @default_image_id unless @default_image_id.nil?
-
-          all_images = list_images
-          official_images = all_images.select {|img| img["official"] == true}
-          ubuntu_lts_images = official_images.select {|img| img["name"] =~ /Ubuntu.*LTS/}
-          ubuntu_lts_i686_images = ubuntu_lts_images.select {|img| img["arch"] == "i686"}
-
-          if ubuntu_lts_i686_images.empty?
-            # Accept other architectures
-            if ubuntu_lts_images.empty?
-              # Accept non-LTS versions of Ubuntu
-              unsorted_images = official_images.select {|img| img["name"] =~ /Ubuntu/}
-            else
-              unsorted_images = ubuntu_lts_images
-            end
-          else
-            unsorted_images = ubuntu_lts_i686_images
-          end
-
-          # Get the latest and use it's ID for the default image
-          @default_image_id = unsorted_images.sort {|a,b| a["created_at"] <=> b["created_at"]}.first["id"]
-        rescue
-          nil
+          Fog::Brightbox::Compute::ImageSelector.new(list_images).latest_ubuntu
         end
       end
 

data/lib/fog/brightbox/compute/image_selector.rb

@@ -0,0 +1,45 @@
+module Fog
+  module Brightbox
+    module Compute
+      #
+      # This selects the preferred image to use based on a number of
+      # conditions
+      #
+      class ImageSelector
+        # Prepares a selector with the API output
+        #
+        # @param [Array<Hash>] images hash matching API output for {Fog::Compute::Brightbox#list_images}
+        #
+        def initialize(images)
+          @images = images
+        end
+
+        # Returns current identifier of the latest version of Ubuntu
+        #
+        # The order of preference is:
+        # * Only Official Brightbox images
+        # * Only Ubuntu images
+        # * Latest by name (alphanumeric sort)
+        # * Latest by creation date
+        #
+        # @note This performs a live query against the API
+        #
+        # @return [String] if image matches containing the identifier
+        # @return [NilClass] if no image matches
+        #
+        def latest_ubuntu
+          @images.select do |img|
+            img["official"] == true &&
+              img["arch"] == "i686" &&
+              img["name"] =~ /ubuntu/i
+          end.sort do |a,b|
+            # Reverse sort so "raring" > "precise" and "13.10" > "13.04"
+            b["name"].downcase <=> a["name"].downcase
+          end.first["id"]
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/cloudstack/compute.rb

@@ -19,6 +19,8 @@ module Fog
 
       model_path 'fog/cloudstack/models/compute'
       model :address
+      model :disk_offering
+      collection :disk_offerings
       model :flavor
       collection :flavors
       model :job
@@ -46,6 +48,7 @@ module Fog
       request :authorize_security_group_ingress
       request :change_service_for_virtual_machine
       request :create_account
+      request :create_disk_offering
       request :create_domain
       request :create_load_balancer_rule
       request :create_network
@@ -58,6 +61,7 @@ module Fog
       request :create_volume
       request :create_zone
       request :delete_account
+      request :delete_disk_offering
       request :delete_domain
       request :delete_load_balancer_rule
       request :delete_port_forwarding_rule
@@ -420,9 +424,73 @@ module Fog
               :domains         => {domain_id => domain},
               :servers         => {},
               :jobs            => {},
-              :volumes         => {},
+              :volumes         => {
+                "89198f7c-0245-aa1d-136a-c5f479ef9db7" => {
+                  "id"=> "89198f7c-0245-aa1d-136a-c5f479ef9db7",
+                  "name"=>"test volume",
+                  "zoneid"=> zone_id,
+                  "zonename"=>"zone-00",
+                  "type"=>"DATADISK",
+                  "deviceid"=>1,
+                  "virtualmachineid"=> "51dcffee-5f9f-29a4-acee-2717e1a3656b",
+                  "vmname"=>"i-2824-11621-VM",
+                  "vmdisplayname"=>"test vm",
+                  "vmstate"=>"Running",
+                  "size"=>17179869184,
+                  "created"=>"2013-04-16T12:33:41+0000",
+                  "state"=>"Ready",
+                  "account"=> 'accountname',
+                  "domainid"=> domain_id,
+                  "domain"=> domain_name,
+                  "storagetype"=>"shared",
+                  "hypervisor"=>"KVM",
+                  "diskofferingid"=> "cc4de87d-672d-4353-abb5-6a8a4c0abf59",
+                  "diskofferingname"=>"Small Disk",
+                  "diskofferingdisplaytext"=>"Small Disk [16GB Disk]",
+                  "storage"=>"ps1",
+                  "attached"=>"2013-04-16T12:34:07+0000",
+                  "destroyed"=>false,
+                  "isextractable"=>false
+                  },
+                },
               :security_groups => {},
-              :snapshots       => {}
+              :snapshots       => {},
+              :disk_offerings  => {
+                "cc4de87d-672d-4353-abb5-6a8a4c0abf59" => {
+                  "id"           => "cc4de87d-672d-4353-abb5-6a8a4c0abf59",
+                  "domainid"     => domain_id,
+                  "domain"       => domain_name,
+                  "name"         => "Small Disk",
+                  "displaytext"  => "Small Disk [16GB Disk]",
+                  "disksize"     => 16,
+                  "created"      => "2013-02-21T03:12:520300",
+                  "iscustomized" => false,
+                  "storagetype"  =>  "shared"
+                },
+                "d5deeb0c-de03-4ebf-820a-dc74221bcaeb" => {
+                  "id"           => "d5deeb0c-de03-4ebf-820a-dc74221bcaeb",
+                  "domainid"     => domain_id,
+                  "domain"       => domain_name,
+                  "name"         => "Medium Disk",
+                  "displaytext"  => "Medium Disk [32GB Disk]",
+                  "disksize"     => 32,
+                  "created"      => "2013-02-21T03:12:520300",
+                  "iscustomized" => false,
+                  "storagetype"  => "shared"
+                }
+              },
+              :os_types  => {
+                "51ef854d-279e-4e68-9059-74980fd7b29b" => {
+                  "id"           => "51ef854d-279e-4e68-9059-74980fd7b29b",
+                  "oscategoryid" => "56f67279-e082-45c3-a01c-d290d6cd4ce2",
+                  "description"  => "Asianux 3(32-bit)"
+                  },
+                "daf124c8-95d8-4756-8e1c-1871b073babb" => {
+                  "id"           => "daf124c8-95d8-4756-8e1c-1871b073babb",
+                  "oscategoryid" => "56f67279-e082-45c3-a01c-d290d6cd4ce2",
+                  "description"  => "Asianux 3(64-bit)"
+                  }
+              }
             }
           end
         end

data/lib/fog/cloudstack/models/compute/disk_offering.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class Cloudstack
+      class DiskOffering < Fog::Model
+        identity  :id,              :aliases => 'id'
+        attribute :created
+        attribute :disk_size,       :aliases => 'disk_size'
+        attribute :display_text,    :aliases => 'display_text'
+        attribute :domain
+        attribute :domain_id,       :aliases => 'domainid'
+        attribute :is_customized,   :aliases => 'iscustomized'
+        attribute :name
+        attribute :storage_type,    :aliases => 'storagetype'
+        attribute :tags
+
+
+        def save
+          requires :display_text, :name
+
+          options = {
+            'displaytext' => display_text,
+            'name'        => name,
+            'customized'  => is_customized,
+            'disksize'    => disk_size,
+            'domain_id'   => domain_id,
+            'storagetype' => storage_type,
+            'tags'        => tags
+          }
+
+          response = service.create_disk_offering(options)
+          merge_attributes(response['creatediskofferingresponse'])
+        end
+
+        def destroy
+          requires :id
+
+          response = service.delete_disk_offering('id' => id )
+          success_status = response['deletediskofferingresponse']['success']
+
+          success_status == 'true'
+        end
+
+      end # DiskOffering
+    end # Cloudstack
+  end # Compute
+end # Fog

data/lib/fog/cloudstack/models/compute/disk_offerings.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/cloudstack/models/compute/disk_offering'
+
+module Fog
+  module Compute
+    class Cloudstack
+
+      class DiskOfferings < Fog::Collection
+
+        model Fog::Compute::Cloudstack::DiskOffering
+
+        def all(options = {})
+          response = service.list_disk_offerings(options)
+          disk_offerings_data = response["listdiskofferingsresponse"]["diskoffering"] || []
+          load(disk_offerings_data)
+        end
+
+        def get(disk_offering_id)
+          response = service.list_disk_offerings('id' => disk_offering_id)
+          disk_offering_data = response["listdiskofferingsresponse"]["diskoffering"].first
+          new(disk_offering_data)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/cloudstack/models/compute/image.rb

@@ -26,7 +26,7 @@ module Fog
         attribute :name
         attribute :os_type_id,         :aliases => 'ostypeid'
         attribute :os_type_name,       :aliases => 'ostypename'
-        attribute :password_enabled,   :aliases => 'ostypename'
+        attribute :password_enabled,   :aliases => 'passwordenabled'
         attribute :project
         attribute :project_id,         :aliases => 'projectid'
         attribute :removed

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

@@ -9,8 +9,9 @@ module Fog
 
         model Fog::Compute::Cloudstack::Server
 
-        def all
-          data = service.list_virtual_machines["listvirtualmachinesresponse"]["virtualmachine"] || []
+        def all(attributes={})
+          response = service.list_virtual_machines(attributes)
+          data = response["listvirtualmachinesresponse"]["virtualmachine"] || []
           load(data)
         end
 

data/lib/fog/cloudstack/requests/compute/create_disk_offering.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class Cloudstack
+      class Real
+
+        # Creates a disk offering.
+        #
+        # {CloudStack API Reference}[http://cloudstack.apache.org/docs/api/apidocs-4.0.0/root_admin/createDiskOffering.html]
+        def create_disk_offering(options={})
+          options.merge!(
+            'command' => 'createDiskOffering'
+          )
+          request(options)
+        end
+
+      end # Real
+
+      class Mock
+
+        def create_disk_offering(options={})
+          disk_offering_id = Fog::Cloudstack.uuid
+
+          first_domain_data = data[:domains].first.last
+          domain_id = options['domainid'] || first_domain_data['id']
+          domain_name = data[:domains][domain_id]['name']
+
+          storage_type = options['storagetype'] || 'shared'
+          customized = options['customized'] || false
+          disk_size = options['disk_size'] || 1
+
+          disk_offering = {
+            "id"           => disk_offering_id,
+            "domainid"     => domain_id,
+            "domain"       => domain_name,
+            "name"         => options['name'],
+            "displaytext"  => options['display_text'],
+            "disksize"     => disk_size,
+            "created"      => Time.now.iso8601,
+            "iscustomized" => customized,
+            "storagetype"  => storage_type
+          }
+
+          self.data[:disk_offerings][disk_offering_id] = disk_offering
+
+          {'creatediskofferingresponse' => disk_offering}
+        end
+      end
+
+    end # Cloudstack
+  end # Compute
+end # Fog

data/lib/fog/cloudstack/requests/compute/delete_disk_offering.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Cloudstack
+      class Real
+
+        # Updates a disk offering.
+        #
+        # {CloudStack API Reference}[http://cloudstack.apache.org/docs/api/apidocs-4.0.0/root_admin/deleteDiskOffering.html]
+        def delete_disk_offering(options={})
+          options.merge!(
+            'command' => 'deleteDiskOffering'
+          )
+          request(options)
+        end
+
+      end # Real
+
+      class Mock
+
+        def delete_disk_offering(options={})
+          disk_offering_id = options['id']
+          data[:disk_offerings].delete(disk_offering_id) if data[:disk_offerings][disk_offering_id]
+
+          { 'deletediskofferingresponse' => { 'success' => 'true' } }
+        end
+
+      end
+
+    end # Cloudstack
+  end # Compute
+end # Fog