fog-aws 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53e5c13a8cdab463ca2f7e696ce8f6be7a28e6b7
-  data.tar.gz: 7c0b522b66731d66b8374cf1cf8d8c8cba679d57
+  metadata.gz: 04b74ccb392ce39559dbdd053081d2e304b52957
+  data.tar.gz: c5010f4e017481193b8f0e84c17b54a2bb3edc6f
 SHA512:
-  metadata.gz: 5c93b6c6b2d5013370a4277bd28002c5b357af8d28846f21c1c44147a1ec4773e15c4ab047795ee5fd718755b66ad153db597be569cbe33e043c930e599e9f01
-  data.tar.gz: 174a539d140553b296d6ef4beb68f792f6f02a67ca3c17a7d25a76c7d1038aade3807ec7efb7be7e1bb0c479c010ad5e790a9e396bd7fec7895d73de4c620c9e
+  metadata.gz: f24cc2d407182a671b21b832ccfbc45fda04f794ac5f6fcb8a117925a86f9df1c82af39d1021d412cf8ca190b98c461807cdeea74322beaaec7af9aafaf33bfa
+  data.tar.gz: e6f134e032e570cc657deec822c02621e27e9a7e891adf3967ddb85b2c0fd48883be9fe33de1578d6349226f8279ae8a5563119cf9894f15e96adc781ddc0183

data/fog-aws.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake',    '~> 10.0'
   spec.add_development_dependency 'shindo',  '~> 0.3'
+  spec.add_development_dependency 'rubyzip', '~> 0.9.9'
 
   spec.add_dependency 'fog-core',  '~> 1.27'
   spec.add_dependency 'fog-json',  '~> 1.0'

data/lib/fog/aws.rb

@@ -45,6 +45,7 @@ module Fog
     autoload :Glacier,          File.expand_path('../aws/glacier', __FILE__)
     autoload :IAM,              File.expand_path('../aws/iam', __FILE__)
     autoload :KMS,              File.expand_path('../aws/kms', __FILE__)
+    autoload :Lambda,           File.expand_path('../aws/lambda', __FILE__)
     autoload :RDS,              File.expand_path('../aws/rds', __FILE__)
     autoload :Redshift,         File.expand_path('../aws/redshift', __FILE__)
     autoload :SES,              File.expand_path('../aws/ses', __FILE__)
@@ -70,6 +71,7 @@ module Fog
     service(:glacier,         'Glacier')
     service(:iam,             'IAM')
     service(:kms,             'KMS')
+    service(:lambda,          'Lambda')
     service(:rds,             'RDS')
     service(:redshift,        'Redshift')
     service(:ses,             'SES')
@@ -148,16 +150,21 @@ module Fog
 
       headers = headers.merge('Host' => options[:host], 'x-amz-date' => date.to_iso8601_basic)
       headers['x-amz-security-token'] = options[:aws_session_token] if options[:aws_session_token]
+      query = options[:query] || {}
 
-      body = ''
-      for key in params.keys.sort
-        unless (value = params[key]).nil?
-          body << "#{key}=#{escape(value.to_s)}&"
+      if !options[:body]
+        body = ''
+        for key in params.keys.sort
+          unless (value = params[key]).nil?
+            body << "#{key}=#{escape(value.to_s)}&"
+          end
         end
+        body.chop!
+      else
+        body = options[:body]
       end
-      body.chop!
 
-      headers['Authorization'] = options[:signer].sign({:method => options[:method], :headers => headers, :body => body, :query => {}, :path => options[:path]}, date)
+      headers['Authorization'] = options[:signer].sign({:method => options[:method], :headers => headers, :body => body, :query => query, :path => options[:path]}, date)
 
       return body, headers
     end
@@ -209,5 +216,10 @@ module Fog
       end
       options
     end
+
+    def self.json_response?(response)
+      return false unless response && response.headers
+      response.get_header('Content-Type') =~ %r{application/json}i ? true : false
+    end
   end
 end

data/lib/fog/aws/errors.rb

@@ -2,11 +2,32 @@ module Fog
   module AWS
     module Errors
       def self.match_error(error)
-        matcher = lambda {|s| s.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)}
-        [error.message, error.response.body].each(&Proc.new {|s|
-            match = matcher.call(s)
-            return {:code => match[1].split('.').last, :message => match[2]} if match
-          })
+        if !Fog::AWS.json_response?(error.response)
+          matchers = [
+            lambda {|s| s.match(/(?:.*<Code>(.*)<\/Code>)(?:.*<Message>(.*)<\/Message>)/m)},
+            lambda {|s| s.match(/.*<(.+Exception)>(?:.*<Message>(.*)<\/Message>)/m)}
+          ]
+          [error.message, error.response.body].each(&Proc.new {|s|
+              matchers.each do |matcher|
+                match = matcher.call(s)
+                return {:code => match[1].split('.').last, :message => match[2]} if match
+              end
+            })
+        else
+          begin
+            full_msg_error = Fog::JSON.decode(error.response.body)
+            if (full_msg_error.has_key?('Message') || full_msg_error.has_key?('message')) &&
+              error.response.headers.has_key?('x-amzn-ErrorType')
+              matched_error = {
+                :code    => error.response.headers['x-amzn-ErrorType'].split(':').first,
+                :message => full_msg_error['Message'] || full_msg_error['message']
+              }
+              return matched_error
+            end
+          rescue Fog::JSON::DecodeError => e
+            Fog::Logger.warning("Error parsing response json - #{e}")
+          end
+        end
         {} # we did not match the message or response body
       end
     end

data/lib/fog/aws/lambda.rb

@@ -0,0 +1,195 @@
+module Fog
+  module AWS
+    class Lambda < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :host, :path, :port, :scheme, :persistent, :region, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at, :version, :instrumentor, :instrumentor_name
+
+      request_path 'fog/aws/requests/lambda'
+      request :create_function
+      request :delete_function
+      request :get_function
+      request :get_function_configuration
+      request :invoke
+      request :list_functions
+      request :update_function_code
+      request :update_function_configuration
+
+      request :get_policy
+      request :add_permission
+      request :remove_permission
+
+      request :create_event_source_mapping
+      request :delete_event_source_mapping
+      request :get_event_source_mapping
+      request :list_event_source_mappings
+      request :update_event_source_mapping
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, region|
+            hash[region] = Hash.new do |region_hash, key|
+              region_hash[key] = {
+                :functions             => {},
+                :permissions           => {},
+                :event_source_mappings => {}
+              }
+            end
+          end
+        end
+
+        attr_reader :region
+        attr_reader :account_id
+        attr_reader :aws_access_key_id
+
+        def initialize(options={})
+          @region            = options[:region] || 'us-east-1'
+          @aws_access_key_id = options[:aws_access_key_id]
+          @account_id        = Fog::AWS::Mock.owner_id
+          @module            = "lambda"
+
+          unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-central-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
+            raise ArgumentError, "Unknown region: #{@region.inspect}"
+          end
+        end
+
+        def data
+          self.class.data[@region][@aws_access_key_id]
+        end
+
+        def reset_data
+          self.class.data[@region].delete(@aws_access_key_id)
+        end
+      end
+
+      class Real
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
+        # Initialize connection to Lambda
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   lambda = Lambda.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #
+        # ==== Returns
+        # * Lambda object with connection to AWS.
+        def initialize(options={})
+          @use_iam_profile    = options[:use_iam_profile]
+          @connection_options = options[:connection_options] || {}
+          @instrumentor       = options[:instrumentor]
+          @instrumentor_name  = options[:instrumentor_name] || 'fog.aws.lambda'
+
+          options[:region] ||= 'us-east-1'
+          @region = options[:region]
+          @host = options[:host] || "lambda.#{options[:region]}.amazonaws.com"
+
+          @path       = options[:path]        || '/'
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || 443
+          @scheme     = options[:scheme]      || 'https'
+          @version    = options[:version]     || '2015-03-31'
+          @connection = Fog::Core::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+
+          setup_credentials(options)
+        end
+
+        attr_reader :region
+
+        def reload
+          @connection.reset
+        end
+
+        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]
+
+          @signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key, @region, 'lambda')
+        end
+
+        def request(params)
+          refresh_credentials_if_expired
+
+          idempotent   = params.delete(:idempotent)
+          parser       = params.delete(:parser)
+          request_path = "/#{@version}#{params.delete(:path)}"
+          query        = params.delete(:query)   || {}
+          method       = params.delete(:method)  || 'POST'
+          expects      = params.delete(:expects) || 200
+          headers      = { 'Content-Type' => 'application/json' }
+
+          headers.merge!(params[:headers] || {})
+
+          body, headers = AWS.signed_params_v4(
+            params,
+            headers,
+            {
+              :method            => method,
+              :aws_session_token => @aws_session_token,
+              :signer            => @signer,
+              :host              => @host,
+              :path              => request_path,
+              :port              => @port,
+              :query             => query,
+              :body              => params[:body]
+            }
+          )
+
+          if @instrumentor
+            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
+              _request(method, request_path, query, body, headers, expects, idempotent, parser)
+            end
+          else
+            _request(method, request_path, query, body, headers, expects, idempotent, parser)
+          end
+        end
+
+        def _request(method, path, query, body, headers, expects, idempotent, parser=nil)
+          response = process_response(@connection.request({
+            :path       => path,
+            :query      => query,
+            :body       => body,
+            :expects    => expects,
+            :idempotent => idempotent,
+            :headers    => headers,
+            :method     => method
+          }), parser)
+        rescue Excon::Errors::HTTPStatusError => error
+          match = Fog::AWS::Errors.match_error(error)
+          raise if match.empty?
+          raise Fog::AWS::Lambda::Error.slurp(error,
+            "#{match[:code]} => #{match[:message]}")
+        end
+
+        def process_response(response, parser)
+          if response &&
+             response.body &&
+             response.body.is_a?(String) &&
+             !response.body.strip.empty? &&
+             Fog::AWS.json_response?(response)
+            begin
+              response.body = Fog::JSON.decode(response.body)
+              response.body = parser.process(response.body) if parser
+            rescue Fog::JSON::DecodeError => e
+              Fog::Logger.warning("Error parsing response json - #{e}")
+              response.body = {}
+            end
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/lambda/base.rb

@@ -0,0 +1,39 @@
+module Fog
+  module AWS
+    module Parsers
+      module Lambda
+        class Base
+          def process(body)
+            body.inject({}) { |h, (k, v)| h[k] = rules(k, v); h }
+          end
+
+          private
+
+          def rules(key, value)
+            case value
+            when Hash
+              process(value)
+            when Array
+              value.map { |i| process(i) }
+            else
+              case key
+              when 'LastModified'
+                Time.parse(value)
+              when 'Policy', 'Statement'
+                begin
+                  Fog::JSON.decode(value)
+                rescue Fog::JSON::DecodeError => e
+                  Fog::Logger.warning("Error parsing response json - #{e}")
+                  {}
+                end
+              else
+                value
+              end
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/lambda/add_permission.rb

@@ -0,0 +1,100 @@
+module Fog
+  module AWS
+    class Lambda
+      class Real
+        require 'fog/aws/parsers/lambda/base'
+
+        # Adds a permission to the access policy associated with the specified AWS Lambda function.
+        # http://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html
+        # ==== Parameters
+        # * FunctionName <~String> - Name of the Lambda function whose access policy you are updating by adding a new permission.
+        # * Action <~String> - AWS Lambda action you want to allow in this statement.
+        # * Principal <~String> - principal who is getting this permission.
+        # * SourceAccount <~String> - AWS account ID (without a hyphen) of the source owner.
+        # * SourceArn <~String> - Amazon Resource Name (ARN) of the source resource to assign permissions.
+        # * StatemendId. <~String> - unique statement identifier.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Statement' <~Hash> - permission statement you specified in the request.
+        def add_permission(params={})
+          function_name  = params.delete('FunctionName')
+          action         = params.delete('Action')
+          principal      = params.delete('Principal')
+          source_account = params.delete('SourceAccount')
+          source_arn     = params.delete('SourceArn')
+          sid            = params.delete('StatementId')
+
+          permission = {
+            'Action'      => action,
+            'Principal'   => principal,
+            'StatementId' => sid
+          }
+          permission['SourceAccount'] = source_account if source_account
+          permission['SourceArn']     = source_arn     if source_arn
+
+          request({
+            :method  => 'POST',
+            :path    => "/functions/#{function_name}/versions/HEAD/policy",
+            :expects => 201,
+            :body    => Fog::JSON.encode(permission),
+            :parser  => Fog::AWS::Parsers::Lambda::Base.new
+          }.merge(params))
+        end
+      end
+
+      class Mock
+        def add_permission(params={})
+          function_id = params.delete('FunctionName')
+          function = self.get_function_configuration(
+            'FunctionName' => function_id
+          ).body
+          function_arn = function['FunctionArn']
+
+          action         = params.delete('Action')
+          principal      = params.delete('Principal')
+          source_account = params.delete('SourceAccount')
+          source_arn     = params.delete('SourceArn')
+          sid            = params.delete('StatementId')
+
+          if action.nil? || action.empty?
+            message = 'Action cannot be blank'
+            raise Fog::AWS::Lambda::Error, message
+          end
+
+          if principal.nil? || principal.empty?
+            message = 'Principal cannot be blank'
+            raise Fog::AWS::Lambda::Error, message
+          end
+
+          if sid.nil? || sid.empty?
+            message = 'Sid cannot be blank'
+            raise Fog::AWS::Lambda::Error, message
+          end
+
+          statement = {
+            'Action'      => [action],
+            'Principal'   => { 'Service' => principal },
+            'Sid'         => sid,
+            'Resource'    => function_arn,
+            'Effect'      => 'Allow'
+          }
+          if source_arn
+            statement['Condition'] = {}
+            statement['Condition']['ArnLike'] = {
+              'AWS:SourceArn' => source_arn
+            }
+          end
+
+          self.data[:permissions][function_arn] ||= []
+          self.data[:permissions][function_arn] << statement
+
+          response = Excon::Response.new
+          response.status = 201
+          response.body = { 'Statement' => statement }
+          response
+        end
+      end
+    end
+  end
+end