elasticity 5.0.1 → 5.0.2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticity
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.0.2
 platform: ruby
 authors:
 - Robert Slifka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-13 00:00:00.000000000 Z
+date: 2015-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -142,7 +142,10 @@ files:
 - Rakefile
 - elasticity.gemspec
 - lib/elasticity.rb
-- lib/elasticity/aws_request.rb
+- lib/elasticity/aws_request_v2.rb
+- lib/elasticity/aws_request_v4.rb
+- lib/elasticity/aws_session.rb
+- lib/elasticity/aws_utils.rb
 - lib/elasticity/bootstrap_action.rb
 - lib/elasticity/custom_jar_step.rb
 - lib/elasticity/emr.rb
@@ -163,7 +166,10 @@ files:
 - lib/elasticity/streaming_step.rb
 - lib/elasticity/sync_to_s3.rb
 - lib/elasticity/version.rb
-- spec/lib/elasticity/aws_request_spec.rb
+- spec/lib/elasticity/aws_request_v2_spec.rb
+- spec/lib/elasticity/aws_request_v4_spec.rb
+- spec/lib/elasticity/aws_session_spec.rb
+- spec/lib/elasticity/aws_utils_spec.rb
 - spec/lib/elasticity/bootstrap_action_spec.rb
 - spec/lib/elasticity/custom_jar_step_spec.rb
 - spec/lib/elasticity/emr_spec.rb
@@ -210,7 +216,10 @@ signing_key:
 specification_version: 4
 summary: Streamlined, programmatic access to Amazon's Elastic Map Reduce service.
 test_files:
-- spec/lib/elasticity/aws_request_spec.rb
+- spec/lib/elasticity/aws_request_v2_spec.rb
+- spec/lib/elasticity/aws_request_v4_spec.rb
+- spec/lib/elasticity/aws_session_spec.rb
+- spec/lib/elasticity/aws_utils_spec.rb
 - spec/lib/elasticity/bootstrap_action_spec.rb
 - spec/lib/elasticity/custom_jar_step_spec.rb
 - spec/lib/elasticity/emr_spec.rb

data/lib/elasticity/aws_request.rb

@@ -1,135 +0,0 @@
-module Elasticity
-
-  class MissingKeyError < StandardError;
-  end
-  class MissingRegionError < StandardError;
-  end
-
-  class AwsRequest
-
-    attr_reader :access_key
-    attr_reader :secret_key
-    attr_reader :host
-    attr_reader :protocol
-
-    # Supported values for options:
-    #  :region - AWS region (e.g. us-west-1)
-    #  :secure - true or false, default true.
-    def initialize(access=nil, secret=nil, options={})
-      # There is a cryptic error if this isn't set
-      if options.has_key?(:region) && options[:region] == nil
-        raise MissingRegionError, 'A valid :region is required to connect to EMR'
-      end
-
-      @access_key = get_access_key(access)
-      @secret_key = get_secret_key(secret)
-      @host = "elasticmapreduce.#{{:region => 'us-east-1'}.merge(options)[:region]}.amazonaws.com"
-      @protocol = {:secure => true}.merge(options)[:secure] ? 'https' : 'http'
-    end
-
-    def submit(ruby_params)
-      aws_params = AwsRequest.convert_ruby_to_aws(ruby_params)
-      signed_params = sign_params(aws_params)
-      begin
-        RestClient.post("#@protocol://#@host", signed_params, :content_type => 'application/x-www-form-urlencoded; charset=utf-8')
-      rescue RestClient::BadRequest => e
-        raise ArgumentError, AwsRequest.parse_error_response(e.http_body)
-      end
-    end
-
-    def ==(other)
-      return false unless other.is_a? AwsRequest
-      return false unless @access_key == other.access_key
-      return false unless @secret_key == other.secret_key
-      return false unless @host == other.host
-      return false unless @protocol == other.protocol
-      true
-    end
-
-    private
-
-    def get_access_key(access)
-      return access if access
-      return ENV['AWS_ACCESS_KEY_ID'] if ENV['AWS_ACCESS_KEY_ID']
-      raise MissingKeyError, 'Please provide an access key or set AWS_ACCESS_KEY_ID.'
-    end
-
-    def get_secret_key(secret)
-      return secret if secret
-      return ENV['AWS_SECRET_ACCESS_KEY'] if ENV['AWS_SECRET_ACCESS_KEY']
-      raise MissingKeyError, 'Please provide a secret key or set AWS_SECRET_ACCESS_KEY.'
-    end
-
-    # (Used from RightScale's right_aws gem.)
-    # EC2, SQS, SDB and EMR requests must be signed by this guy.
-    # See: http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?REST_RESTAuth.html
-    #      http://developer.amazonwebservices.com/connect/entry.jspa?externalID=1928
-    def sign_params(service_hash)
-      service_hash.merge!({
-        'AWSAccessKeyId' => @access_key,
-        'Timestamp' => Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.000Z'),
-        'SignatureVersion' => '2',
-        'SignatureMethod' => 'HmacSHA256'
-      })
-      canonical_string = service_hash.keys.sort.map do |key|
-        "#{AwsRequest.aws_escape(key)}=#{AwsRequest.aws_escape(service_hash[key])}"
-      end.join('&')
-      string_to_sign = "POST\n#{@host.downcase}\n/\n#{canonical_string}"
-      signature = AwsRequest.aws_escape(Base64.encode64(OpenSSL::HMAC.digest("sha256", @secret_key, string_to_sign)).strip)
-      "#{canonical_string}&Signature=#{signature}"
-    end
-
-    # (Used from RightScale's right_aws gem)
-    # Escape a string according to Amazon's rules.
-    # See: http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?REST_RESTAuth.html
-    def self.aws_escape(param)
-      param.to_s.gsub(/([^a-zA-Z0-9._~-]+)/n) do
-        '%' + $1.unpack('H2' * $1.size).join('%').upcase
-      end
-    end
-
-    # Since we use the same structure as AWS, we can generate AWS param names
-    # from the Ruby versions of those names (and the param nesting).
-    def self.convert_ruby_to_aws(params)
-      result = {}
-      params.each do |key, value|
-        case value
-          when Array
-            prefix = "#{camelize(key.to_s)}.member"
-            value.each_with_index do |item, index|
-              if item.is_a?(String)
-                result["#{prefix}.#{index+1}"] = item
-              else
-                convert_ruby_to_aws(item).each do |nested_key, nested_value|
-                  result["#{prefix}.#{index+1}.#{nested_key}"] = nested_value
-                end
-              end
-            end
-          when Hash
-            prefix = "#{camelize(key.to_s)}"
-            convert_ruby_to_aws(value).each do |nested_key, nested_value|
-              result["#{prefix}.#{nested_key}"] = nested_value
-            end
-          else
-            result[camelize(key.to_s)] = value
-        end
-      end
-      result
-    end
-
-    # (Used from Rails' ActiveSupport)
-    def self.camelize(word)
-      word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-    end
-
-    # AWS error responses all follow the same form.  Extract the message from
-    # the error document.
-    def self.parse_error_response(error_xml)
-      xml_doc = Nokogiri::XML(error_xml)
-      xml_doc.remove_namespaces!
-      xml_doc.xpath("/ErrorResponse/Error/Message").text
-    end
-
-  end
-
-end

data/spec/lib/elasticity/aws_request_spec.rb

@@ -1,274 +0,0 @@
-describe Elasticity::AwsRequest do
-
-  before do
-    Timecop.freeze(Time.at(1302461096))
-  end
-
-  after do
-    Timecop.return
-  end
-
-  subject do
-    Elasticity::AwsRequest.new('access', 'secret')
-  end
-
-  describe '#initialize' do
-
-    context 'when access and/or secret keys are provided' do
-      it 'should set them to the provided values' do
-        subject.access_key.should == 'access'
-        subject.secret_key.should == 'secret'
-      end
-    end
-
-    context 'when :region is nil' do
-      it 'should be an error' do
-        expect {
-          Elasticity::AwsRequest.new('_', '_', :region => nil)
-        }.to raise_error Elasticity::MissingRegionError, 'A valid :region is required to connect to EMR'
-      end
-    end
-
-    context 'when either access or secret key is not provided or nil' do
-
-      context 'when the proper environment variables are set' do
-
-        context 'when access and secret key are not provided' do
-          let(:default_values) { Elasticity::AwsRequest.new }
-          before do
-            ENV.stub(:[]).with('AWS_ACCESS_KEY_ID').and_return('ENV_ACCESS')
-            ENV.stub(:[]).with('AWS_SECRET_ACCESS_KEY').and_return('ENV_SECRET')
-          end
-          it 'should set access and secret keys' do
-            default_values.access_key.should == 'ENV_ACCESS'
-            default_values.secret_key.should == 'ENV_SECRET'
-          end
-        end
-
-        context 'when access and secret key are nil' do
-          let(:nil_values) { Elasticity::AwsRequest.new(nil, nil) }
-          before do
-            ENV.stub(:[]).with('AWS_ACCESS_KEY_ID').and_return('ENV_ACCESS')
-            ENV.stub(:[]).with('AWS_SECRET_ACCESS_KEY').and_return('ENV_SECRET')
-          end
-          it 'should set access and secret keys' do
-            nil_values.access_key.should == 'ENV_ACCESS'
-            nil_values.secret_key.should == 'ENV_SECRET'
-          end
-        end
-
-      end
-
-      context 'when the environment variables are not set' do
-        let(:missing_something) { Elasticity::AwsRequest.new }
-        context 'when the access key is not set' do
-          before do
-            ENV.stub(:[]).with('AWS_ACCESS_KEY_ID').and_return(nil)
-            ENV.stub(:[]).with('AWS_SECRET_ACCESS_KEY').and_return('_')
-          end
-          it 'should raise an error' do
-            expect {
-              missing_something.access_key
-            }.to raise_error(Elasticity::MissingKeyError, 'Please provide an access key or set AWS_ACCESS_KEY_ID.')
-          end
-        end
-        context 'when the secret key is not set' do
-          before do
-            ENV.stub(:[]).with('AWS_ACCESS_KEY_ID').and_return('_')
-            ENV.stub(:[]).with('AWS_SECRET_ACCESS_KEY').and_return(nil)
-          end
-          it 'should raise an error' do
-            expect {
-              missing_something.access_key
-            }.to raise_error(Elasticity::MissingKeyError, 'Please provide a secret key or set AWS_SECRET_ACCESS_KEY.')
-          end
-        end
-      end
-
-    end
-
-  end
-
-  describe '#host' do
-
-    context 'when the region is not specified' do
-      its(:host) { should == 'elasticmapreduce.us-east-1.amazonaws.com' }
-    end
-
-    context 'when the region is specified' do
-      let(:request_with_region) do
-        Elasticity::AwsRequest.new('_', '_', {:region => 'us-west-1'})
-      end
-      it 'should incorporate the region into the hostname' do
-        request_with_region.host.should == 'elasticmapreduce.us-west-1.amazonaws.com'
-      end
-    end
-
-  end
-
-  describe '#protocol' do
-
-    context 'when :secure is not specified' do
-      let(:default_request) { Elasticity::AwsRequest.new('_', '_') }
-      it 'should be https by default' do
-        default_request.protocol.should == 'https'
-      end
-    end
-
-    context 'when :secure is specified' do
-
-      context 'when :secure is truthy' do
-        let(:secure_request) { Elasticity::AwsRequest.new('_', '_', {:secure => true}) }
-        it 'should be https' do
-          secure_request.protocol.should == 'https'
-        end
-      end
-
-      context 'when :secure is falsey' do
-        let(:insecure_request) { Elasticity::AwsRequest.new('_', '_', {:secure => false}) }
-        it 'should be http' do
-          insecure_request.protocol.should == 'http'
-        end
-      end
-
-    end
-
-  end
-
-  describe '#sign_params' do
-    it 'should sign according to AWS rules' do
-      signed_params = subject.send(:sign_params, {})
-      signed_params.should == 'AWSAccessKeyId=access&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2011-04-10T18%3A44%3A56.000Z&Signature=t%2BccC38VxCKyk2ROTKo9vnECsntKoU0RBAFklHWP5bE%3D'
-    end
-  end
-
-  describe '#submit' do
-
-    let(:request) do
-      Elasticity::AwsRequest.new('_', '_').tap do |r|
-        r.instance_variable_set(:@host, 'HOSTNAME')
-        r.instance_variable_set(:@protocol, 'PROTOCOL')
-      end
-    end
-
-    it 'should POST a properly assembled request' do
-      ruby_params = {}
-      aws_params = {}
-      Elasticity::AwsRequest.should_receive(:convert_ruby_to_aws).with(ruby_params).and_return(ruby_params)
-      request.should_receive(:sign_params).with(aws_params).and_return('SIGNED_PARAMS')
-      RestClient.should_receive(:post).with('PROTOCOL://HOSTNAME', 'SIGNED_PARAMS', :content_type => 'application/x-www-form-urlencoded; charset=utf-8')
-      request.submit(ruby_params)
-    end
-
-    context 'when there is an EMR error with the request' do
-      let(:error_message) { 'ERROR_MESSAGE' }
-      let(:error_xml) do
-        <<-XML
-          <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-            <Error>
-              <Message>#{error_message}</Message>
-            </Error>
-          </ErrorResponse>
-        XML
-      end
-      let(:error) do
-        RestClient::BadRequest.new.tap do |error|
-          error.stub(:http_body => error_xml)
-        end
-      end
-
-      it 'should raise an Argument error with the body of the error' do
-        RestClient.should_receive(:post).and_raise(error)
-        expect {
-          request.submit({})
-        }.to raise_error(ArgumentError, error_message)
-      end
-    end
-
-  end
-
-  describe '#==' do
-
-    describe 'basic equality checks with subject' do
-      let(:same_object) { subject }
-      let(:same_values) { Elasticity::AwsRequest.new('access', 'secret', {}) }
-      let(:diff_type) { Object.new }
-
-      it { should == same_object }
-      it { should == same_values }
-      it { should_not == diff_type }
-    end
-
-    describe 'deep comparisons' do
-
-      it 'should fail on access key check' do
-        Elasticity::AwsRequest.new('access', '_').should_not == Elasticity::AwsRequest.new('_', '_')
-      end
-
-      it 'should fail on secret key check' do
-        Elasticity::AwsRequest.new('_', 'secret').should_not == Elasticity::AwsRequest.new('_', '_')
-      end
-
-      it 'should fail on host check' do
-        aws1 = Elasticity::AwsRequest.new('_', '_', :region => 'us-east-1')
-        aws2 = Elasticity::AwsRequest.new('_', '_', :region => 'us-west-1')
-        aws1.should_not == aws2
-      end
-
-      it 'should fail on protocol check' do
-        aws1 = Elasticity::AwsRequest.new('_', '_', :secure => true)
-        aws2 = Elasticity::AwsRequest.new('_', '_', :secure => false)
-        aws1.should_not == aws2
-      end
-
-    end
-
-  end
-
-  describe '.convert_ruby_to_aws' do
-    it 'should convert the params' do
-      add_jobflow_steps_params = {
-        :job_flow_id => 'j-1',
-        :steps => [
-          {
-            :action_on_failure => 'CONTINUE',
-            :name => 'First New Job Step',
-            :hadoop_jar_step => {
-              :args => ['arg1', 'arg2', 'arg3',],
-              :jar => 'first_step.jar',
-              :main_class => 'first_class.jar'
-            }
-          },
-            {
-              :action_on_failure => 'CANCEL_AND_WAIT',
-              :name => 'Second New Job Step',
-              :hadoop_jar_step => {
-                :args => ['arg4', 'arg5', 'arg6',],
-                :jar => 'second_step.jar',
-                :main_class => 'second_class.jar'
-              }
-            }
-        ]
-      }
-      expected_result = {
-        'JobFlowId' => 'j-1',
-        'Steps.member.1.Name' => 'First New Job Step',
-        'Steps.member.1.ActionOnFailure' => 'CONTINUE',
-        'Steps.member.1.HadoopJarStep.Jar' => 'first_step.jar',
-        'Steps.member.1.HadoopJarStep.MainClass' => 'first_class.jar',
-        'Steps.member.1.HadoopJarStep.Args.member.1' => 'arg1',
-        'Steps.member.1.HadoopJarStep.Args.member.2' => 'arg2',
-        'Steps.member.1.HadoopJarStep.Args.member.3' => 'arg3',
-        'Steps.member.2.Name' => 'Second New Job Step',
-        'Steps.member.2.ActionOnFailure' => 'CANCEL_AND_WAIT',
-        'Steps.member.2.HadoopJarStep.Jar' => 'second_step.jar',
-        'Steps.member.2.HadoopJarStep.MainClass' => 'second_class.jar',
-        'Steps.member.2.HadoopJarStep.Args.member.1' => 'arg4',
-        'Steps.member.2.HadoopJarStep.Args.member.2' => 'arg5',
-        'Steps.member.2.HadoopJarStep.Args.member.3' => 'arg6'
-      }
-      Elasticity::AwsRequest.send(:convert_ruby_to_aws, add_jobflow_steps_params).should == expected_result
-    end
-  end
-
-end