dynamodb 0.0.2 → 1.1.1

data/.gitignore

@@ -1,2 +1,3 @@
 .rvmrc
+.rbenv*
 Gemfile.lock

data/Gemfile

@@ -1,2 +1,3 @@
-source :rubygems
+source "https://rubygems.org"
+gem "rake"
 gemspec

data/README.md

@@ -15,15 +15,33 @@ requests are done through `#post`. The first argument is the name of the
 operation, the second is a hash that will be converted to JSON and used as the
 request body.
 
+Responses come back as `SuccessResponse` or `FailureResponse` objects.
+
     require 'dynamodb'
 
-    conn = DynamoDB::Connection.new 'ACCESS_KEY', 'SECRET_KEY'
+    > conn = DynamoDB::Connection.new(access_key_id: 'ACCESS_KEY', secret_access_key: 'SECRET_KEY')
+     => #<DynamoDB::Connection:...>
+
+    > response = conn.post(:ListTables)
+     => #<DynamoDB::SuccessResponse:...>
+
+    > response.data
+     => {"TableNames"=>["my-dynamo-table"]}
+
+For operations that return `Item` or `Items` keys, there are friendly accessors
+on the responses that also cast the values into strings and numbers:
 
-    conn.post :ListTables
-    => {"TableNames" => ["someTable", "anotherTable"]}
+    > response = conn.post(:GetItem, {:TableName => "my-dynamo-table", :Key => {:S => "some-key"}})
+     => #<DynamoDB::SuccessResponse:...>
 
-    conn.post :GetItem, {:TableName => "someTable", :Key => {:S => "someKey"}}
-    => { ... }
+    > response.item
+     => {"text"=>"Hey there"}
+
+    > response = conn.post(:Query, {...})
+     => #<DynamoDB::SuccessResponse:...>
+
+    > response.items
+     => [{...}]
 
 TODO
 ----
@@ -33,7 +51,7 @@ TODO
 Credits
 -------
 
-This project started as a fork of [Jedlik](https://github.com/hashmal/jedlik) 
+This project started as a fork of [Jedlik](https://github.com/hashmal/jedlik)
 by [Jérémy Pinat](https://github.com/hashmal) but has significantly diverged.
 
 License
@@ -41,8 +59,20 @@ License
 
 Copyright (c) 2011-2012 GroupMe, Inc.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/dynamodb.gemspec

@@ -1,6 +1,8 @@
+require "./lib/dynamodb/version"
+
 Gem::Specification.new do |s|
   s.name         = 'dynamodb'
-  s.version      = '0.0.2'
+  s.version      = DynamoDB::VERSION
   s.summary      = "Communicate with Amazon DynamoDB."
   s.description  = "Communicate with Amazon DynamoDB. Raw access to the full API without having to handle temporary credentials or HTTP requests by yourself."
   s.authors      = ["Brandon Keene", "Dave Yeu"]
@@ -11,7 +13,6 @@ Gem::Specification.new do |s|
   s.executables  = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.homepage     = 'http://github.com/groupme/dynamodb'
 
-  s.add_runtime_dependency 'typhoeus', '0.4.2'
   s.add_runtime_dependency 'multi_json', '1.3.7'
 
   s.add_development_dependency 'rspec', '2.8.0'

data/lib/dynamodb.rb

@@ -1,30 +1,22 @@
-require 'typhoeus'
+require "uri"
 require 'time'
-require 'base64'
-require 'openssl'
 require 'cgi'
 require 'multi_json'
 
 module DynamoDB
-  class BaseError < RuntimeError
-    attr_reader :response
-
-    def initialize(response)
-      @response = response
-      super("#{response.code}: #{response.body}")
-    end
-  end
-
+  class BaseError < RuntimeError; end
   class ClientError < BaseError; end
   class ServerError < BaseError; end
-  class TimeoutError < BaseError; end
   class AuthenticationError < BaseError; end
 
-  require 'dynamodb/typhoeus/request'
-  require 'dynamodb/credentials'
-  require 'dynamodb/security_token_service'
+  Credentials = Struct.new(:access_key_id, :secret_access_key)
+
+  require 'dynamodb/version'
   require 'dynamodb/connection'
-  require 'dynamodb/response'
+  require 'dynamodb/http_handler'
+  require 'dynamodb/request'
+  require 'dynamodb/success_response'
+  require 'dynamodb/failure_response'
 
   class << self
     def serialize(object)
@@ -70,6 +62,14 @@ module DynamoDB
         {"N" => (value ? 1 : 0).to_s}
       when Time
         {"N" => value.to_f.to_s}
+      when Array
+        if value.all? {|n| n.kind_of?(String) }
+          {"SS" => value.uniq}
+        elsif value.all? {|n| n.kind_of?(Numeric) }
+          {"NS" => value.uniq}
+        else
+          raise ClientError.new("cannot mix data types in sets")
+        end
       else
         {"S" => value.to_s}
       end
@@ -81,6 +81,7 @@ module DynamoDB
       case k
       when "N" then v.include?('.') ? v.to_f : v.to_i
       when "S" then v.to_s
+      when "SS","NS" then v
       else
         raise "Type not recoginized: #{k}"
       end

data/lib/dynamodb/connection.rb

@@ -1,97 +1,61 @@
 module DynamoDB
   # Establishes a connection to Amazon DynamoDB using credentials.
   class Connection
-    DEFAULTS = {
-      :endpoint => 'dynamodb.us-east-1.amazonaws.com',
-      :timeout  => 5000 # ms
-    }
+    class << self
+      def http_handler
+        @http_handler ||= HttpHandler.new
+      end
 
-    # Acceptable `opts` keys are:
-    #
-    #     :endpoint # DynamoDB endpoint to use.
-    #               # Default: 'dynamodb.us-east-1.amazonaws.com'
+      def http_handler=(new_http_handler)
+        @http_handler = new_http_handler
+      end
+    end
+
+    # Create a connection
+    # uri:          # default 'https://dynamodb.us-east-1.amazonaws.com/'
+    # timeout:      # default 5 seconds
+    # api_version:  # default 
     #
     def initialize(opts = {})
-      opts = DEFAULTS.merge opts
-
-      if opts[:token_service]
-        @sts = opts[:token_service]
-      elsif opts[:access_key_id] && opts[:secret_access_key]
-        @sts = SecurityTokenService.new(opts[:access_key_id], opts[:secret_access_key])
+      if opts[:access_key_id] && opts[:secret_access_key]
+        @credentials = DynamoDB::Credentials.new(opts[:access_key_id], opts[:secret_access_key])
       else
         raise ArgumentError.new("access_key_id and secret_access_key are required")
       end
 
-      @endpoint = opts[:endpoint]
-      @timeout  = opts[:timeout]
+      @uri = URI(opts[:uri] || "https://dynamodb.us-east-1.amazonaws.com/")
+      set_timeout(opts[:timeout]) if opts[:timeout]
+
+      @api_version = opts[:api_version] || "DynamoDB_20111205"
     end
 
-    # Create and send a request to DynamoDB.
-    # Returns a hash extracted from the response body.
+    # Create and send a request to DynamoDB
+    #
+    # This returns either a SuccessResponse or a FailureResponse.
     #
     # `operation` can be any DynamoDB operation. `data` is a hash that will be
     # used as the request body (in JSON format). More info available at:
-    #
     # http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide
     #
     def post(operation, data={})
-      credentials = @sts.credentials
-
-      request = new_request(credentials, operation, MultiJson.dump(data))
-      request.sign(credentials)
-
-      hydra.queue(request)
-      hydra.run
-      response = request.response
-
-      if response.success?
-        case operation
-        when :Query, :Scan, :GetItem
-          DynamoDB::Response.new(response)
-        else
-          MultiJson.load(response.body)
-        end
-      else
-        raise_error(response)
-      end
+      request = DynamoDB::Request.new(
+        uri:         @uri,
+        credentials: @credentials,
+        api_version: @api_version,
+        operation:   operation,
+        data:        data
+      )
+      http_handler.handle(request)
     end
 
     private
 
-    def hydra
-      Typhoeus::Hydra.hydra
+    def http_handler
+      self.class.http_handler
     end
 
-    def new_request(credentials, operation, body)
-      Typhoeus::Request.new "https://#@endpoint/",
-        :method  => :post,
-        :body    => body,
-        :timeout => @timeout,
-        :connect_timeout => @timeout,
-        :headers => {
-          'host'                 => @endpoint,
-          'content-type'         => "application/x-amz-json-1.0",
-          'x-amz-date'           => (Time.now.utc.strftime "%a, %d %b %Y %H:%M:%S GMT"),
-          'x-amz-security-token' => credentials.session_token,
-          'x-amz-target'         => "DynamoDB_20111205.#{operation}",
-        }
-    end
-
-    def raise_error(response)
-      if response.timed_out?
-        raise TimeoutError.new(response)
-      else
-        case response.code
-        when 400..499
-          raise ClientError.new(response)
-        when 500..599
-          raise ServerError.new(response)
-        when 0
-          raise ServerError.new(response)
-        else
-          raise BaseError.new(response)
-        end
-      end
+    def set_timeout(timeout)
+      http_handler.timeout = timeout
     end
   end
 end

data/lib/dynamodb/failure_response.rb

@@ -0,0 +1,41 @@
+module DynamoDB
+  # Failed response from Dynamo
+  #
+  # The #error can be:
+  # * `ClientError` for 4XX responses
+  # * `ServerError` for 5XX or unknown responses
+  # * Network errors, which are enumerated in HttpHandler
+  class FailureResponse
+    attr_accessor :error, :body, :code
+
+    def initialize(http_response = nil)
+      @http_response = http_response
+    end
+
+    def success?
+      false
+    end
+
+    def error
+      @error ||= http_response_error
+    end
+
+    def body
+      @body ||= @http_response && @http_response.body
+    end
+
+    def code
+      @code ||= @http_response && @http_response.code
+    end
+
+    private
+
+    def http_response_error
+      if (400..499).include?(code.to_i)
+        ClientError.new("#{code}: #{@http_response.message}")
+      else
+        ServerError.new("#{code}: #{@http_response.message}")
+      end
+    end
+  end
+end

data/lib/dynamodb/http_handler.rb

@@ -0,0 +1,74 @@
+require "net/http/connection_pool"
+
+module DynamoDB
+  # Process HTTP requests
+  #
+  # Kudos to AWS's NetHttpHandler class for the inspiration here.
+  # Re-using a single instance of this class is recommended, since
+  # it relies upon persistent HTTP connections managed by a pool.
+  class HttpHandler
+    DEFAULT_TIMEOUT = 5 # seconds
+
+    NETWORK_ERRORS = [
+      SocketError,
+      EOFError,
+      IOError,
+      Errno::ECONNABORTED,
+      Errno::ECONNRESET,
+      Errno::EPIPE,
+      Errno::EINVAL,
+      Timeout::Error,
+      Errno::ETIMEDOUT
+    ]
+
+    attr_writer :timeout
+
+    def initialize(options = {})
+      @pool    = Net::HTTP::ConnectionPool.new
+      @timeout = options[:timeout] || DEFAULT_TIMEOUT
+    end
+
+    # Perform an HTTP request
+    #
+    # The argument should be a `DynamoDB::Request` object, and the
+    # return value is either a `DynamoDB::SuccessResponse` or a
+    # `DynamoDB::FailureResponse`.
+    def handle(request)
+      connection = @pool.connection_for(request.uri.host, {
+        port:            request.uri.port,
+        ssl:             request.uri.scheme == "https",
+        ssl_verify_peer: true
+      })
+      connection.read_timeout = @timeout
+
+      begin
+        response = nil
+        connection.request(build_http_request(request)) do |http_response|
+          if http_response.code.to_i < 300
+            response = SuccessResponse.new(http_response)
+          else
+            response = FailureResponse.new(http_response)
+          end
+        end
+        response
+      rescue *NETWORK_ERRORS => e
+        FailureResponse.new.tap do |response|
+          response.body = nil
+          response.code = nil
+          response.error = e
+        end
+      end
+    end
+
+    def build_http_request(request)
+      Net::HTTP::Post.new(request.uri.to_s).tap do |http_request|
+        http_request.body = request.body
+
+        request.headers.each do |key, value|
+          http_request[key] = value
+        end
+      end
+    end
+
+  end
+end

data/lib/dynamodb/request.rb

@@ -0,0 +1,107 @@
+require "base64"
+require "openssl"
+
+module DynamoDB
+  class Request
+    class << self
+      def digest(signing_string, key)
+        Base64.encode64(
+          OpenSSL::HMAC.digest('sha256', key, Digest::SHA256.digest(signing_string))
+        ).strip
+      end
+    end
+
+    attr_reader :uri, :datetime, :credentials, :region, :data, :service, :operation, :api_version
+
+    def initialize(args = {})
+      @uri          = args[:uri]
+      @credentials  = args[:credentials]
+      @operation    = args[:operation]
+      @data         = args[:data]
+      @api_version  = args[:api_version]
+      @region       = args[:region] || "us-east-1"
+      @datetime     = Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
+      @service      = "dynamodb"
+    end
+
+    def our_headers
+      {
+        "user-agent"           => "groupme/dynamodb",
+        "host"                 => uri.host,
+        "content-type"         => "application/x-amz-json-1.0",
+        "content-length"       => body.size,
+        "x-amz-date"           => datetime,
+        "x-amz-target"         => "#{api_version}.#{operation}",
+        "x-amz-content-sha256" => hexdigest(body || '')
+      }
+    end
+
+    def headers
+      @headers ||= our_headers.merge("authorization" => authorization)
+    end
+
+    def body
+      @body ||= MultiJson.dump(data)
+    end
+
+    def authorization
+      parts = []
+      parts << "AWS4-HMAC-SHA256 Credential=#{credentials.access_key_id}/#{credential_string}"
+      parts << "SignedHeaders=#{our_headers.keys.sort.join(";")}"
+      parts << "Signature=#{signature}"
+      parts.join(', ')
+    end
+
+    def signature
+      k_secret = credentials.secret_access_key
+      k_date = hmac("AWS4" + k_secret, datetime[0,8])
+      k_region = hmac(k_date, region)
+      k_service = hmac(k_region, service)
+      k_credentials = hmac(k_service, 'aws4_request')
+      hexhmac(k_credentials, string_to_sign)
+    end
+
+    def string_to_sign
+      parts = []
+      parts << 'AWS4-HMAC-SHA256'
+      parts << datetime
+      parts << credential_string
+      parts << hexdigest(canonical_request)
+      parts.join("\n")
+    end
+
+    def credential_string
+      parts = []
+      parts << datetime[0,8]
+      parts << region
+      parts << service
+      parts << 'aws4_request'
+      parts.join("/")
+    end
+
+    def canonical_request
+      parts = []
+      parts << "POST"
+      parts << uri.path
+      parts << uri.query
+      parts << our_headers.sort.map {|k, v| [k,v].join(':')}.join("\n") + "\n"
+      parts << "content-length;content-type;host;user-agent;x-amz-content-sha256;x-amz-date;x-amz-target"
+      parts << our_headers['x-amz-content-sha256']
+      parts.join("\n")
+    end
+
+    def hexdigest value
+      digest = Digest::SHA256.new
+      digest.update(value)
+      digest.hexdigest
+    end
+
+    def hmac key, value
+      OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha256'), key, value)
+    end
+
+    def hexhmac key, value
+      OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new('sha256'), key, value)
+    end
+  end
+end