fog 1.14.0 → 1.15.0

data/lib/fog/aws/requests/iam/upload_server_certificate.rb

@@ -71,7 +71,7 @@ module Fog
           end
 
           if self.data[:server_certificates][name]
-            raise Fog::AWS::IAM::EntityAlreadyExists.new
+            raise Fog::AWS::IAM::EntityAlreadyExists.new("The Server Certificate with name #{name} already exists.")
           else
             response.status = 200
             path = options['Path'] || "/"

data/lib/fog/aws/requests/rds/describe_orderable_db_instance_options.rb

@@ -0,0 +1,76 @@
+module Fog
+  module AWS
+    class RDS
+      class Real
+
+        require 'fog/aws/parsers/rds/describe_orderable_db_instance_options'
+
+        # Describe all or specified load db instances
+        # http://docs.amazonwebservices.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html
+        # ==== Parameters
+        # * Engine <~String> - The name of the engine to retrieve DB Instance options for. Required.
+        # * Options <~Hash> - Hash of options. Optional. The following keys are used:
+        #   * :db_instance_class <~String> - Filter available offerings matching the specified DB Instance class. Optional.
+        #   * :engine_version <~String> - Filters available offerings matching the specified engine version. Optional.
+        #   * :license_model <~String> - Filters available offerings matching the specified license model. Optional.
+        #   * :marker <~String> - The pagination token provided in the previous request. If this parameter is specified the response includes only records beyond the marker, up to MaxRecords. Optional.
+        #   * :max_records <~Integer> - The maximum number of records to include in the response. If more records exist, a pagination token is included in the response. Optional.
+        #   * :vpc <~Boolean> - Filter to show only the available VPC or non-VPC offerings. Optional.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          params = {}
+          params['Engine'] = engine if engine
+          params['DBInstanceClass'] = opts[:db_instance_class] if opts[:db_instance_class]
+          params['EngineVersion'] = opts[:engine_version] if opts[:engine_version]
+          params['LicenseModel'] = opts[:license_model] if opts[:license_model]
+          params['Marker'] = opts[:marker] if opts[:marker]
+          params['MaxRecords'] = opts[:max_records] if opts[:max_records]
+          params['Vpc'] = opts[:vpc] if opts[:vpc]
+
+          request({
+            'Action'  => 'DescribeOrderableDBInstanceOptions',
+            :parser   => Fog::Parsers::AWS::RDS::DescribeOrderableDBInstanceOptions.new
+          }.merge(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_orderable_db_instance_options(engine=nil, opts={})
+          instance_options = []
+          response = Excon::Response.new
+          if engine
+            (opts[:db_instance_class] || %w(db.m2.xlarge db.m1.large)).each do |size|
+              instance_options << {'MultiAZCapable' => true,
+                                   'Engine' => engine,
+                                   'LicenseModel' => opts[:license_model] || 'general-public-license',
+                                   'ReadReplicaCapable' => true,
+                                   'EngineVersion' => opts[:engine_version] || '5.6.12',
+                                   'AvailabilityZones' => [
+                                      {'Name' => 'us-east-1b', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1c', 'ProvisionedIopsCapable' => true},
+                                      {'Name' => 'us-east-1d', 'ProvisionedIopsCapable' => false},
+                                      {'Name' => 'us-east-1e', 'ProvisionedIopsCapable' => true}],
+                                   'DBInstanceClass' => size,
+                                   'Vpc' => opts[:vpc].nil? ? true : opts[:vpc]}
+
+            end
+          else
+            raise Fog::AWS::RDS::NotFound.new('An engine must be specified to retrieve orderable instance options')
+          end
+
+          response.status = 200
+          response.body = {
+              'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id },
+              'DescribeOrderableDBInstanceOptionsResult' => { 'OrderableDBInstanceOptions' => instance_options }
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/ses/verify_domain_identity.rb

@@ -16,7 +16,7 @@ module Fog
         #     * 'ResponseMetadata'<~Hash>:
         #       * 'VerificationToken'<~String> - Verification token
         #       * 'RequestId'<~String> - Id of request
-        def verify_domain(domain)
+        def verify_domain_identity(domain)
           request({
             'Action'           => 'VerifyDomainIdentity',
             'Domain'           => domain,

data/lib/fog/bin/rackspace.rb

@@ -21,6 +21,8 @@ class Rackspace < Fog::Bin
         Fog::Rackspace::Identity
       when :databases
         Fog::Rackspace::Databases
+      when :monitoring
+        Fog::Rackspace::Monitoring
       else
         raise ArgumentError, "Unrecognized service: #{key}"
       end
@@ -52,6 +54,8 @@ class Rackspace < Fog::Bin
           Fog::Rackspace::Databases.new
         when :block_storage
           Fog::Rackspace::BlockStorage.new
+        when :monitoring
+          Fog::Rackspace::Monitoring.new
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end

data/lib/fog/brightbox/models/compute/collaboration.rb

@@ -25,14 +25,22 @@ module Fog
             :email => email
           }.delete_if { |k, v| v.nil? || v == "" }
 
-          data = connection.create_collaboration(options)
+          data = service.create_collaboration(options)
+          merge_attributes(data)
+          true
+        end
+
+        def resend
+          requires :identity
+          data = service.resend_collaboration(identity)
           merge_attributes(data)
           true
         end
 
         def destroy
           requires :identity
-          connection.destroy_collaboration(identity)
+          data = service.destroy_collaboration(identity)
+          merge_attributes(data)
           true
         end
 

data/lib/fog/brightbox/models/compute/collaborations.rb

@@ -8,13 +8,37 @@ module Fog
         model Fog::Compute::Brightbox::Collaboration
 
         def all
-          data = connection.list_collaborations
+          data = service.list_collaborations
           load(data)
         end
 
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_collaboration(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        # Invites a user (via an email) to collaborate on the currently scoped
+        # account at the +role+ level.
+        #
+        # @param [String] email The email address to use for the invitation
+        # @param [String] role The role being granted. Only (+admin+ is
+        #   currently supported
+        # @return [Fog::Compute::Brightbox::Collaboration]
+        #
+        def invite(email, role)
+          return nil if email.nil? || email == ""
+          return nil if role.nil? || role == ""
+          options = {:email => email, :role => role}
+          data = service.create_collaboration(options)
+          new(data)
+        end
+
         def destroy
           requires :identity
-          connection.destroy_collaboration(identity)
+          service.destroy_collaboration(identity)
           true
         end
       end

data/lib/fog/brightbox/models/compute/user_collaboration.rb

@@ -17,9 +17,24 @@ module Fog
           account['id'] || account[:id]
         end
 
+        def accept
+          requires :identity
+          data = service.accept_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
+        def reject
+          requires :identity
+          data = service.reject_user_collaboration(identity)
+          merge_attributes(data)
+          true
+        end
+
         def destroy
           requires :identity
-          connection.destroy_user_collaboration(identity)
+          data = service.destroy_user_collaboration(identity)
+          merge_attributes(data)
           true
         end
 

data/lib/fog/brightbox/models/compute/user_collaborations.rb

@@ -8,13 +8,21 @@ module Fog
         model Fog::Compute::Brightbox::UserCollaboration
 
         def all
-          data = connection.list_user_collaborations
+          data = service.list_user_collaborations
           load(data)
         end
 
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = service.get_user_collaboration(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
         def destroy
           requires :identity
-          connection.destroy_user_collaboration(identity)
+          service.destroy_user_collaboration(identity)
           true
         end
       end

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

@@ -34,6 +34,8 @@ module Fog
         attribute :root_device_id,                          :aliases => 'rootdeviceid'
         attribute :root_device_type,                        :aliases => 'rootdevicetype'
         attribute :group
+        attribute :key_name,                                :aliases => 'keypair'
+        attribute :user_data,                                :aliases => 'userdata'
         attribute :security_group_list,    :type => :array, :aliases => 'securitygroup'
         attribute :nics,                   :type => :array, :aliases => 'nic'
 
@@ -92,6 +94,8 @@ module Fog
             'ipaddress'         => ip_address,
             'iptonetworklist'   => ip_to_network_list,
             'projectid'         => project_id,
+            'keypair'           => key_name,
+            'userdata'           => user_data,
           }
 
           options.merge!('networkids' => network_ids) if network_ids

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

@@ -23,7 +23,7 @@ module Fog
 
         def get(server_id)
           servers = service.list_virtual_machines('id' => server_id)["listvirtualmachinesresponse"]["virtualmachine"]
-          unless servers.empty? || servers.nil?
+          unless servers.nil? || servers.empty?
             new(servers.first)
           end
         rescue Fog::Compute::Cloudstack::BadRequest

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

@@ -4,7 +4,7 @@ module Fog
   module Compute
     class Server < Fog::Model
 
-      attr_writer :username, :private_key, :private_key_path, :public_key, :public_key_path, :ssh_port
+      attr_writer :username, :private_key, :private_key_path, :public_key, :public_key_path, :ssh_port, :ssh_options
 
       def username
         @username ||= 'root'
@@ -32,13 +32,21 @@ module Fog
         @ssh_port ||= 22
       end
 
+      def ssh_options
+        @ssh_options ||= {}
+        ssh_options = @ssh_options.merge({:port => ssh_port})
+        if private_key
+          ssh_options[:key_data] = [private_key]
+          ssh_options[:auth_methods] = ["publickey"]
+        end
+        ssh_options
+      end
+
       def scp(local_path, remote_path, upload_options = {})
         require 'net/scp'
         requires :public_ip_address, :username
 
-        scp_options = {:port => ssh_port}
-        scp_options[:key_data] = [private_key] if private_key
-        Fog::SCP.new(public_ip_address, username, scp_options).upload(local_path, remote_path, upload_options)
+        Fog::SCP.new(public_ip_address, username, ssh_options).upload(local_path, remote_path, upload_options)
       end
 
       alias_method :scp_upload, :scp
@@ -47,23 +55,21 @@ module Fog
         require 'net/scp'
         requires :public_ip_address, :username
 
-        scp_options = {:port => ssh_port}
-        scp_options[:key_data] = [private_key] if private_key
-        Fog::SCP.new(public_ip_address, username, scp_options).download(remote_path, local_path, download_options)
+        Fog::SCP.new(public_ip_address, username, ssh_options).download(remote_path, local_path, download_options)
       end
 
       def ssh(commands, options={}, &blk)
         require 'net/ssh'
         requires :public_ip_address, :username
 
-        options[:key_data] = [private_key] if private_key
-        options[:port] ||= ssh_port
+        options = ssh_options.merge(options)
+
         Fog::SSH.new(public_ip_address, username, options).run(commands, &blk)
       end
 
       def sshable?(options={})
         ready? && !public_ip_address.nil? && !!Timeout::timeout(8) { ssh('pwd', options) }
-      rescue SystemCallError, Net::SSH::AuthenticationFailed, Timeout::Error
+      rescue SystemCallError, Net::SSH::AuthenticationFailed, Net::SSH::Disconnect, Timeout::Error
         false
       end
 

data/lib/fog/core.rb

@@ -8,6 +8,7 @@ require 'formatador'
 require 'openssl'
 require 'time'
 require 'timeout'
+require 'ipaddr'
 
 # internal core dependencies
 require "fog/version"

data/lib/fog/core/collection.rb

@@ -142,4 +142,22 @@ module Fog
     end
 
   end
+
+  # Base class for collection classes whose 'all' method returns only a single page of results and passes the
+  # 'Marker' option along as self.filters[:marker]
+  class PagedCollection < Collection
+
+    def each(filters=filters)
+      if block_given?
+        begin
+          page = self.all(filters)
+          # We need to explicitly use the base 'each' method here on the page, otherwise we get infinite recursion
+          base_each = Fog::Collection.instance_method(:each)
+          base_each.bind(page).call { |item| yield item }
+        end while self.filters[:marker]
+      end
+      self
+    end
+
+  end
 end

data/lib/fog/core/credentials.rb

@@ -50,11 +50,16 @@ module Fog
     @credentials = new_credentials
   end
 
+  def self.symbolize_credential?(key)
+    ![:headers].include?(key)
+  end
+
   def self.symbolize_credentials(args)
     if args.is_a? Hash
       copy = Array.new
       args.each do |key, value|
-        copy.push(key.to_sym, self.symbolize_credentials(value))
+        obj = symbolize_credential?(key) ? self.symbolize_credentials(value) : value
+        copy.push(key.to_sym, obj)
       end
       Hash[*copy]
     else

data/lib/fog/core/mock.rb

@@ -34,6 +34,22 @@ module Fog
       raise Fog::Errors::MockNotImplemented.new("Contributions welcome!")
     end
 
+    def self.random_ip(opts = {:version => :v4})
+      version = opts[:version]
+      if version == :v6
+        bit_length = 128
+        family = Socket::AF_INET6
+      elsif version == :v4
+        bit_length = 32
+        family = Socket::AF_INET
+      else
+        raise ArgumentError, "Unknown IP version: #{version}"
+      end
+
+      seed = 1 + rand((2**bit_length)-1)
+      IPAddr.new(seed, family).to_s
+    end
+
     def self.random_base64(length)
       random_selection(
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",

data/lib/fog/digitalocean/compute.rb

@@ -90,17 +90,46 @@ module Fog
           params[:query].merge!(:api_key   => @digitalocean_api_key)
           params[:query].merge!(:client_id => @digitalocean_client_id)
 
-          response = @connection.request(params)
+          response = retry_event_lock { parse @connection.request(params) }
 
           unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
             if response.body['status'] != 'OK'
-              raise Fog::Errors::Error.new response.body.to_s
+              case response.body['error_message']
+              when /No Droplets Found/
+                raise Fog::Errors::NotFound.new
+              else
+                raise Fog::Errors::Error.new response.body.to_s
+              end
             end
           end
           response
         end
 
+        private
+
+        def parse(response)
+          return response if response.body.empty?
+          response.body = Fog::JSON.decode(response.body)
+          response
+        end
+
+        def retry_event_lock
+          count   = 0
+          reponse = nil
+          while count < 5
+            response = yield
+
+            if response.body && response.body['error_message'] =~ /There is already a pending event for the droplet/
+              count += 1
+              sleep count ** 3
+            else
+              break
+            end
+          end
+
+          response
+        end
+
       end
     end
   end