elastic-mapreduce 0.0.1

data/lib/amazon/coral/awsquery.rb

@@ -0,0 +1,128 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'uri'
+require 'amazon/coral/identityhandler'
+require 'amazon/coral/httpdestinationhandler'
+require 'amazon/coral/awsqueryhandler'
+require 'amazon/coral/v0signaturehandler'
+require 'amazon/coral/v1signaturehandler'
+require 'amazon/coral/v2signaturehandler'
+require 'amazon/coral/awsqueryurihandler'
+require 'amazon/coral/httphandler'
+require 'amazon/coral/orchestrator'
+
+module Amazon
+  module Coral
+    
+    class AwsQuery
+      
+      @@identity_arg_keys = [:aws_access_key, :aws_secret_key, :http_authorization, :http_client_x509_cert, :http_client_x509_key]
+      @@recognized_arg_keys = [:endpoint, :uri, :signature_algorithm, :ca_file, :verbose, 
+                               :aws_access_key, :aws_secret_key, :http_authorization, :http_client_x509_cert, :http_client_x509_key,
+                               :timeout, :connect_timeout]
+      
+      # Creates an Orchestrator capable of processing AWS/QUERY requests.  Possible arguments include:
+      # [:endpoint]
+      #   The HTTP URL at which the service is located.
+      # [:signature_algorithm]
+      #   The AWS signature version to be used to sign outgoing requests.  Current choices are:
+      #     :V0 :V1 :V2
+      #   By default, the version 2 signing algorithm is used.
+      #   All signing may be disabled by passing the value 'nil' as the signature algorithm.
+      # [:aws_access_key]
+      #   An AWS access key to associate with every outgoing request.
+      #   This parameter is optional and may be specified on a per-request basis as well.
+      # [:aws_secret_key]
+      #   An AWS secret key to associate with every outgoing request.
+      #   This parameter is optional and may be specified on a per-request basis as well.
+      # [:http_client_x509_cert]
+      #   A base64-encoded X509 certificate to sign outgoing requests.
+      #   Requires that the x509 key also be specified.
+      # [:http_client_x509_key]
+      #   A base64-encoded private key for an X509 certificate to sign outgoing requests.
+      #   Requires that the x509 certificate also be specified.
+      # [:http_authorization]
+      #   The content of an http-authorization header to send with the request.
+      #   Used for services which require HTTP basic authentication.
+      # [:ca_file]
+      #   A Certificate Authority file to pass to the HttpHandler.
+      # [:timeout]
+      #   The socket read timeout to use during service calls (see HttpHandler for details)
+      # [:connect_timeout]
+      #   A timeout to use for establishing a connection to the service (see HttpHandler for details)
+      # [:verbose]
+      #   A verbosity flag to pass to the HttpHandler.
+      #
+      # Example usage:
+      #   orchestrator = AwsQuery.new_orchestrator(:endpoint => "http://localhost:8000", :signature_algorithm => :V2)
+      #   client = ExampleClient.new(orchestrator)
+      def AwsQuery.new_orchestrator(args)
+        check_args(args)
+        return Orchestrator.new(new_chain(args))
+      end
+
+      private
+      def AwsQuery.new_chain(args)
+        # remap args, add defaults where necessary:
+        
+        # support deprecated :uri mechanism of specifying service endpoint
+        args[:endpoint] = args[:uri] if args[:endpoint].nil?
+        
+        # default to V2 if no algorithm is specified
+        args[:signature_algorithm] = :V2 if args[:signature_algorithm].nil?
+        
+        # support the deprecated mechanism for specifying AWS account information
+        args[:aws_access_key] = args[:access_key] if !args.has_key?(:aws_access_key) && args.has_key?(:access_key)
+        args[:aws_secret_key] = args[:secret_key] if !args.has_key?(:aws_secret_key) && args.has_key?(:secret_key)
+        
+        
+        
+        # build up the chain:
+        chain = []
+        
+        # allow user to preload identity attributes to be used on all requests
+        identity_args = {}
+        @@identity_arg_keys.each {|k|
+          identity_args[k] = args[k] if args.has_key?(k)
+        }
+        chain << IdentityHandler.new(identity_args) unless identity_args.empty?
+        
+        # set the remote endpoint
+        chain << HttpDestinationHandler.new(args[:endpoint])
+        
+        # use the AwsQuery protocol
+        chain << AwsQueryHandler.new({:api_version => args[:api_version], :content_type => args[:content_type]})
+        
+        # select a signing algorithm
+        case args[:signature_algorithm].to_sym
+        when :V0
+          chain << V0SignatureHandler.new
+        when :V1
+          chain << V1SignatureHandler.new
+        when :V2
+          chain << V2SignatureHandler.new
+        end
+
+        # collect the query string and update the destination URL
+        chain << AwsQueryUriHandler.new
+
+        # make connection over HTTP
+        chain << HttpHandler.new( {:ca_file => args[:ca_file], :verbose => args[:verbose],
+                                    :timeout => args[:timeout], :connect_timeout => args[:connect_timeout]} )
+
+        return chain
+      end
+
+      def AwsQuery.check_args(args)
+        log = LogFactory.getLog('Amazon::Coral::AwsQuery')
+
+        args.each_key do |key|
+          log.info("Unknown argument: #{key}") unless @@recognized_arg_keys.include?(key)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/amazon/coral/awsquerychainhelper.rb

@@ -0,0 +1,92 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'uri'
+require 'amazon/coral/identityhandler'
+require 'amazon/coral/httpdestinationhandler'
+require 'amazon/coral/awsqueryhandler'
+require 'amazon/coral/v0signaturehandler'
+require 'amazon/coral/v1signaturehandler'
+require 'amazon/coral/v2signaturehandler'
+require 'amazon/coral/awsqueryurihandler'
+require 'amazon/coral/httphandler'
+
+module Amazon
+  module Coral
+
+    # Constructs a handler chain appropriate for issuing requests using the AWS/QUERY protocol.
+    # This class is deprecated in favor of the use of the AwsQuery class.  Clients generated with
+    # up-to-date versions of the generator will no longer depend on this class.
+    class AwsQueryChainHelper < Array
+
+      @@identity_arg_keys = [:aws_access_key, :aws_secret_key, :http_authorization, :http_client_x509_cert, :http_client_x509_key]
+
+
+      # Creates a chain.  Possible arguments are:
+      # [:endpoint]
+      #   The HTTP URL at which the service is located.
+      # [:signature_algorithm]
+      #   The AWS signature version to be used to sign outgoing requests.  Current choices are:
+      #     :V0 :V1 :V2
+      # [:aws_access_key]
+      #   An AWS access key to associate with every outgoing request.
+      #   This parameter is optional and may be specified on a per-request basis as well.
+      # [:aws_secret_key]
+      #   An AWS secret key to associate with every outgoing request.
+      #   This parameter is optional and may be specified on a per-request basis as well.
+      # [:ca_file]
+      #   A Certificate Authority file to pass to the HttpHandler.
+      # [:verbose]
+      #   A verbosity flag to pass to the HttpHandler.
+      def initialize(args)
+
+        # remap args, add defaults where necessary:
+
+        # support deprecated :uri mechanism of specifying service endpoint
+        args[:endpoint] = args[:uri] if args[:endpoint].nil?
+
+        # default to V2 if no algorithm is specified
+        args[:signature_algorithm] = :V2 if args[:signature_algorithm].nil?
+
+        # support the deprecated mechanism for specifying AWS account information
+        args[:aws_access_key] = args[:access_key] if !args.has_key?(:aws_access_key) && args.has_key?(:access_key)
+        args[:aws_secret_key] = args[:secret_key] if !args.has_key?(:aws_secret_key) && args.has_key?(:secret_key)
+
+
+
+        # build up the chain:
+
+        # allow user to preload identity attributes to be used on all requests
+        identity_args = {}
+        @@identity_arg_keys.each {|k|
+          identity_args[k] = args[k] if args.has_key?(k)
+        }
+        self << IdentityHandler.new(identity_args) unless identity_args.empty?
+
+        # set the remote endpoint
+        self << HttpDestinationHandler.new(args[:endpoint])
+
+        # use the AwsQuery protocol
+        self << AwsQueryHandler.new
+
+        # select a signing algorithm
+        case args[:signature_algorithm].to_sym
+        when :V0
+          self << V0SignatureHandler.new
+        when :V1
+          self << V1SignatureHandler.new
+        when :V2
+          self << V2SignatureHandler.new
+        end
+
+        # collect the query string and update the destination URL
+        self << AwsQueryUriHandler.new
+
+        # make connection over HTTP
+        self << HttpHandler.new( {:ca_file => args[:ca_file], :verbose => args[:verbose]} )
+      end
+
+    end
+
+  end
+end

data/lib/amazon/coral/awsqueryhandler.rb

@@ -0,0 +1,170 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'json/lexer'
+require 'json/objects'
+require 'rexml/document'
+require 'amazon/coral/handler'
+require 'amazon/coral/querystringmap'
+require 'amazon/coral/logfactory'
+require 'amazon/aws/exceptions'
+
+module Amazon
+  module Coral
+
+    class AwsQueryHandler < Handler
+
+      def initialize(args = {})
+        @api_version = args[:api_version]
+        @content_type = args[:content_type]
+
+        @log = LogFactory.getLog('Amazon::Coral::AwsQueryHandler')
+      end
+
+      def before(job)
+        request = job.request
+
+        operation_name = request[:operation_name]
+
+        query_string_map = QueryStringMap.new(request[:value])
+        query_string_map['Action'] = operation_name.to_s
+        if @content_type then
+           query_string_map['ContentType'] = @content_type
+        end
+        if @api_version then
+           query_string_map['Version'] = @api_version
+        end
+
+        request[:query_string_map] = query_string_map
+        request[:http_verb] = 'POST'
+
+        @log.info "Making request to operation #{operation_name} with parameters #{query_string_map}"
+      end
+
+      def after(job)
+        operation_name = job.request[:operation_name]
+
+        reply = job.reply
+
+        @log.info "Received response body: #{reply[:value]}"
+
+        json_result = nil
+        begin
+          if @content_type == 'JSON' then
+            json_result = JSON::Lexer.new(reply[:value]).nextvalue
+            reply[:value] = get_value(operation_name, json_result)
+          else
+            reply[:value] = convert_to_json(reply[:value])
+          end
+        rescue
+          code = reply[:http_status_code]
+          message = reply[:http_status_message]
+
+          raise "#{code} : #{message}" unless code.to_i == 200
+          raise "Failed parsing response: #{$!}\n"
+        end
+
+        aws_error?(reply[:response], reply[:value]) if @content_type != 'JSON'
+      end
+
+      private
+      def get_value(operation_name, json_result)
+        # If there was an error, unwrap it and return
+        return {"Error" => json_result["Error"]} if json_result["Error"]
+
+        # Otherwise unwrap the valid response
+        json_result = json_result["#{operation_name}Response"]
+        json_result = json_result["#{operation_name}Result"]
+        return json_result
+      end
+
+      private 
+      def convert_to_json(document)
+        doc = REXML::Document.new(document)
+        array = []
+        doc.elements.each do |elem|
+          array << xml_to_json(elem) if elem.kind_of?(REXML::Element)
+        end
+        raise "Failed parsing response: #{$!}\n" if array.length > 1
+        
+        return array.first
+      end
+
+      private 	
+      def xml_to_json(parent)
+        array  = []
+        struct = {}
+        parent.children.each do |elem|
+          if elem.kind_of?(REXML::Element) then
+            if elem.name == "item" then
+              array << xml_to_json(elem)
+            else
+              if struct[elem.name] != nil then
+                if ! struct[elem.name].is_a?(Array) then
+                  struct[elem.name] = [ struct[elem.name] ]
+                end
+                struct[elem.name] << xml_to_json(elem)
+              else
+                struct[elem.name] = xml_to_json(elem)
+              end
+            end
+          end
+        end
+        if array.size > 0 then
+          return array
+        elsif struct.keys.size > 0 then
+          return struct
+        else
+          return parent.text
+        end
+      end
+      
+      private
+      def aws_error?(response, body)
+	# This method has been copied and adapted from:
+	#--
+	# Amazon Web Services EC2 + ELB API Ruby library
+	#
+	# Ruby Gem Name::  amazon-ec2
+	# Author::    Glenn Rempe  (mailto:glenn@rempe.us)
+	# Copyright:: Copyright (c) 2007-2009 Glenn Rempe
+	# License::   Distributes under the same terms as Ruby
+	# Home::      http://github.com/grempe/amazon-ec2/tree/master
+	#++
+
+        # return false if we got a HTTP 200 code,
+        # otherwise there is some type of error (40x,50x) and
+        # we should try to raise an appropriate exception
+        # from one of our exception classes defined in
+        # exceptions.rb
+        return false if response.is_a?(Net::HTTPSuccess)
+
+        raise RuntimeError, "Unexpected server error. response.body is: #{body}" if response.is_a?(Net::HTTPServerError)
+
+        # Check that the Error element is in the place we would expect.
+        # and if not raise a generic error exception
+        unless body['Errors']['Error'].length >= 2
+          raise RuntimeError, "Unexpected error format. response.body is: #{body}"
+        end
+
+        # An valid error response looks like this:
+        # <?xml version="1.0"?><Response><Errors><Error><Code>InvalidParameterCombination</Code><Message>Unknown parameter: foo</Message></Error></ Errors><RequestID>291cef62-3e86-414b-900e-17246eccfae8</RequestID></Response>
+        # AWS throws some exception codes that look like Error.SubError.  Since we can't name classes this way
+        # we need to strip out the '.' in the error 'Code' and we name the error exceptions with this
+        # non '.' name as well.
+        error_code    = body['Errors']['Error']['Code']
+        error_message = body['Errors']['Error']['Message']
+
+        # Raise one of our specific error classes if it exists.
+        # otherwise, throw a generic EC2 Error with a few details.
+        if AWS.const_defined?(error_code)
+          raise AWS.const_get(error_code), error_message
+        else
+          raise Error, error_message
+        end
+      end
+
+    end
+
+  end
+end

data/lib/amazon/coral/awsqueryurihandler.rb

@@ -0,0 +1,34 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'uri'
+require 'amazon/coral/handler'
+require 'amazon/coral/logfactory'
+
+module Amazon
+  module Coral
+
+    # Compiles the request URL from AwsQueryHandler and any intervening
+    # signature handler.
+    class AwsQueryUriHandler < Handler
+      def initialize
+        @log = LogFactory.getLog('Amazon::Coral::AwsQueryUriHandler')
+      end
+
+      def before(job)
+        http_verb = job.request[:http_verb]
+
+        if http_verb.nil?
+          raise "http_verb must be defined"
+        elsif http_verb == 'GET' || http_verb == 'HEAD'
+          job.request[:http_uri].query = job.request[:query_string_map].to_s
+        else
+          job.request[:http_query_map] = job.request[:query_string_map]
+        end
+
+        @log.debug "Final request URI: #{job.request[:http_uri]}"
+      end
+    end
+
+  end
+end

data/lib/amazon/coral/call.rb

@@ -0,0 +1,68 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'uuidtools'
+
+module Amazon
+  module Coral
+
+    class Call 
+
+      # Create a new Call object tied to a specific Dispatcher.
+      def initialize(dispatcher)
+        @dispatcher = dispatcher
+        @identity = {}
+        @request_id = nil
+      end
+
+      # Specify a hash containing identity information for the outgoing request.
+      # This is protocol specific but typically contains account names, certificates or other credentials.
+      def identity=(i)
+        @identity = i.to_hash
+      end
+
+      # Retrieve the hash of identity information for the outgoing request.
+      # The returned hash is mutable such that callers may add or remove identity information from it.
+      def identity
+        @identity
+      end
+
+      # Specify the request ID to attach to the outgoing request.  (Internal only)
+      def request_id=(r)
+        @request_id = r
+      end
+
+      # Retrieve the request ID returned by the remote service.
+      def request_id
+        @request_id
+      end
+
+      # Invoke the remote service and return the result.
+      def call(input = {})
+        begin
+          @request_id = UUID.random_create if @request_id.nil?
+
+          return @dispatcher.dispatch(self, input)
+        rescue Timeout::Error => timeout
+          return {
+            "Error" => {
+              "Type" => "Receiver",
+              "Code" => "Timeout",
+              "Details" => timeout
+            }
+          }
+        rescue Exception => e
+          return {
+            "Error" => {
+              "Type" => "Sender",
+              "Code" => "InternalFailure",
+              "Details" => e
+            }
+          }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/amazon/coral/dispatcher.rb

@@ -0,0 +1,33 @@
+#
+# Copyright 2008-2010 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+module Amazon
+  module Coral
+
+    # Dispatches requests to a particular remote service operation.
+    class Dispatcher
+
+      # Instantiates a Dispatcher with the specified Orchestrator and
+      # strings declaring the service and operation to which requests
+      # will be directed.
+      def initialize(orchestrator, service_name, operation_name)
+        @orchestrator = orchestrator
+        @service_name = service_name
+        @operation_name = operation_name
+      end
+
+      # Invoke the remote service and produce a result for the
+      # provided Call object and input hash.
+      def dispatch(call, input)
+        request = {
+          :operation_name => @operation_name, :service_name => @service_name, 
+          :identity => call.identity, :id => call.request_id, :value => input
+        }
+        reply = @orchestrator.orchestrate(request)
+
+        return reply[:value]
+      end
+    end
+  end
+end
+

data/lib/amazon/coral/ec2client.rb

@@ -0,0 +1,91 @@
+#
+# Copyright 2008-2011 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+
+require 'amazon/coral/dispatcher'
+require 'amazon/coral/call'
+require 'amazon/coral/service'
+
+module Amazon
+  module Coral
+
+    # Client interface for calling Ec2.
+    #
+    # The client supports two mechanisms to invoke each remote service call: a simple approach
+    # which directly calls the remote service, or a Call based mechanism that allows you to
+    # control aspects of the outgoing request such as request-id and identity attributes.
+    #
+    # Each instance of a client interface is backed by an Orchestrator object which manages
+    # the processing of each request to the remote service.
+    # Clients can be instantiated with a custom orchestrator or with presets corresponding to
+    # particular protocols.  Inputs and return values to the direct service-call methods and
+    # the Call.call methods are hashes.
+    class Ec2Client
+      # Construct a new client.  Takes an orchestrator through which to process requests.
+      # See additional constructors below to use pre-configured orchestrators for specific protocols.
+      #
+      # [orchestrator]
+      #   The Orchestrator is responsible for actually making the remote service call.  Clients
+      #   construct requests, hand them off to the orchestrator, and receive responses in return.
+      def initialize(orchestrator)
+        @allocateAddressDispatcher = Dispatcher.new(orchestrator, 'Ec2', 'AllocateAddress')
+        @associateAddressDispatcher = Dispatcher.new(orchestrator, 'Ec2', 'AssociateAddress')
+      end
+
+
+      # Instantiates a call object to invoke the AllocateAddress operation:
+      #
+      # Example usage:
+      #   my_call = my_client.newAllocateAddressCall
+      #   # set identity information if needed
+      #   my_call.identity[:aws_access_key] = my_access_key
+      #   my_call.identity[:aws_secret_key] = my_secret_key
+      #   # make the remote call
+      #   my_call.call(my_input)
+      #   # retrieve the request-id returned by the server
+      #   my_request_id = my_call.request_id
+      def newAllocateAddressCall
+        Call.new(@allocateAddressDispatcher)
+      end
+
+      def newAssociateAddressCall
+        Call.new(@associateAddressDispatcher)
+      end
+
+
+      # Shorthand method to invoke the AllocateAddress operation:
+      #
+      # Example usage:
+      #   my_client.AllocateAddress(my_input)
+      def AllocateAddress(input = {})
+        newAllocateAddressCall.call(input)
+      end
+      
+      # Shorthand method to invoke the AssociateAddress operation:
+      #
+      # Example usage:
+      #   my_client.AssociateAddress(my_input)
+      def AssociateAddress(input = {})
+        newAssociateAddressCall.call(input)
+      end
+
+      #TODO: Add stubs for all other Ec2 WS operations here, see http://s3.amazonaws.com/ec2-downloads/2010-11-15.ec2.wsdl
+
+
+      # Instantiates the client with an orchestrator configured for use with AWS/QUERY.
+      # Use of this constructor is deprecated in favor of using the AwsQuery class:
+      #   client = Ec2Client.new(AwsQuery.new_orchestrator(args))
+      def Ec2Client.new_aws_query(args)
+        require 'amazon/coral/awsquery'
+        Ec2Client.new(AwsQuery.new_orchestrator(args))
+      end
+
+    end
+
+    # allow running from the command line
+    Service.new(:service => 'Ec2', :operations => [
+                                                     'AllocateAddress',
+                                                     'AssociateAddress'
+                                                  ]).main if caller.empty?
+  end
+end
+