gapinc-fog 1.12.1.2.1 → 1.14.0

data/lib/fog/aws/requests/sts/assume_role.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class STS
+      class Real
+
+        require 'fog/aws/parsers/sts/assume_role'
+        
+        # Assume Role
+        #
+        # ==== Parameters
+        # * role_session_name<~String> - An identifier for the assumed role.
+        # * role_arn<~String> - The ARN of the role the caller is assuming.
+        # * external_id<~String> - An optional unique identifier required by the assuming role's trust identity.
+        # * policy<~String> - An optional JSON policy document
+        # * duration<~Integer> - Duration (of seconds) for the assumed role credentials to be valid (default 3600)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Arn'<~String>: The ARN of the assumed role/user
+        #     * 'AccessKeyId'<~String>: The AWS access key of the temporary credentials for the assumed role
+        #     * 'SecretAccessKey'<~String>: The AWS secret key of the temporary credentials for the assumed role
+        #     * 'SessionToken'<~String>: The AWS session token of the temporary credentials for the assumed role
+        #     * 'Expiration'<~Time>: The expiration time of the temporary credentials for the assumed role
+        #
+        # ==== See Also
+        # http://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html
+        #
+
+        def assume_role(role_session_name, role_arn, external_id=nil, policy=nil, duration=3600)
+          request({
+            'Action'          => 'AssumeRole',
+            'RoleSessionName' => role_session_name,
+            'RoleArn'         => role_arn,
+            'Policy'          => policy && Fog::JSON.encode(policy),
+            'DurationSeconds' => duration,
+            'ExternalId'      => external_id,
+            :idempotent       => true,
+            :parser           => Fog::Parsers::AWS::STS::AssumeRole.new
+          })
+        end
+        
+      end
+    end
+  end
+end

data/lib/fog/aws/ses.rb

@@ -5,6 +5,9 @@ module Fog
     class SES < Fog::Service
       extend Fog::AWS::CredentialFetcher::ServiceMethods
 
+      class InvalidParameterError < Fog::Errors::Error; end
+      class MessageRejected < Fog::Errors::Error; end
+
       requires :aws_access_key_id, :aws_secret_access_key
       recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at
 
@@ -103,15 +106,28 @@ module Fog
           end
           body.chop! # remove trailing '&'
 
-          response = @connection.request({
-            :body       => body,
-            :expects    => 200,
-            :headers    => headers,
-            :idempotent => idempotent,
-            :host       => @host,
-            :method     => 'POST',
-            :parser     => parser
-          })
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => headers,
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            match = Fog::AWS::Errors.match_error(error)
+            raise if match.empty?
+            raise case match[:code]
+                  when 'MessageRejected'
+                    Fog::AWS::SES::MessageRejected.slurp(error, match[:message])
+                  when 'InvalidParameterValue'
+                    Fog::AWS::SES::InvalidParameterError.slurp(error, match[:message])
+                  else
+                    Fog::AWS::SES::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
+                  end
+          end
 
           response
         end

data/lib/fog/aws/sts.rb

@@ -3,16 +3,18 @@ require 'fog/aws'
 module Fog
   module AWS
     class STS < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
 
       class EntityAlreadyExists < Fog::AWS::STS::Error; end
       class ValidationError < Fog::AWS::STS::Error; end
 
       requires :aws_access_key_id, :aws_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
+      recognizes :host, :path, :port, :scheme, :persistent, :aws_session_token, :use_iam_profile, :aws_credentials_expire_at
 
       request_path 'fog/aws/requests/sts'
       request :get_federation_token
       request :get_session_token
+      request :assume_role
 
       class Mock
         def self.data
@@ -33,7 +35,8 @@ module Fog
         end
 
         def initialize(options={})
-          @aws_access_key_id = options[:aws_access_key_id]
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
         end
 
         def data
@@ -43,10 +46,14 @@ module Fog
         def reset_data
           self.class.data.delete(@aws_access_key_id)
         end
+
+        def setup_credentials(options)
+          @aws_access_key_id = options[:aws_access_key_id]
+        end
       end
 
       class Real
-
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
         # Initialize connection to STS
         #
         # ==== Notes
@@ -67,10 +74,10 @@ module Fog
         def initialize(options={})
           require 'fog/core/parser'
 
-          @aws_access_key_id      = options[:aws_access_key_id]
-          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @use_iam_profile = options[:use_iam_profile]
+          setup_credentials(options)
           @connection_options     = options[:connection_options] || {}
-          @hmac       = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
           @host       = options[:host]        || 'sts.amazonaws.com'
           @path       = options[:path]        || '/'
           @persistent = options[:persistent]  || false
@@ -85,6 +92,14 @@ module Fog
 
         private
 
+        def setup_credentials(options)
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @aws_session_token      = options[:aws_session_token]
+          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+        end
+
         def request(params)
           idempotent  = params.delete(:idempotent)
           parser      = params.delete(:parser)
@@ -93,6 +108,7 @@ module Fog
             params,
             {
               :aws_access_key_id  => @aws_access_key_id,
+              :aws_session_token  => @aws_session_token,
               :hmac               => @hmac,
               :host               => @host,
               :path               => @path,

data/lib/fog/bin/openstack.rb

@@ -15,6 +15,8 @@ class OpenStack < Fog::Bin
         Fog::Storage::OpenStack
       when :volume
         Fog::Volume::OpenStack
+      when :metering
+        Fog::Metering::OpenStack
       else
         raise ArgumentError, "Unrecognized service: #{key}"
       end
@@ -41,6 +43,9 @@ class OpenStack < Fog::Bin
         when :volume
           Fog::Logger.warning("OpenStack[:volume] is not recommended, use Volume[:openstack] for portability")
           Fog::Volume.new(:provider => 'OpenStack')
+        when :metering
+          Fog::Logger.warning("OpenStack[:metering] is not recommended, use Metering[:openstack] for portability")
+          Fog::Metering.new(:provider => 'OpenStack')
         else
           raise ArgumentError, "Unrecognized service: #{key.inspect}"
         end

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/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/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+/",