simplydb 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 JT Archie
+
+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/README.rdoc

@@ -0,0 +1,37 @@
+= simplydb
+
+A minimal interface to Amazon SimpleDB that has separation of interfaces. From the low level HTTP request access to high level Ruby abstraction ORM.
+
+  require 'rubygems'
+  require 'simplydb'
+
+  interface = SimplyDB::Interface.new({
+    :access_key => ENV['AWS_ACCESS_KEY'],
+    :secret_key => ENV['AWS_SECRET_KEY']
+  })
+
+  if interface.create_domain("MyDomain")
+    interface.put_attributes('MyDomain', 'Item123', {'color'=>['red','brick','garnet']})
+
+    attributes = interface.get_attributes('MyDomain', 'Item123')
+    puts "Item123 = #{attributes.inspect}"
+
+    items = interface.select("select color from MyDomain where color = 'brick'")
+    puts "Items = #{items.inspect}"
+
+    interface.delete_domain("MyDomain")
+  end
+  
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 JT Archie. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "simplydb"
+    gem.summary = %Q{A minimal interface to Amazon SimpleDB.}
+    gem.description = %Q{A minimal interface to Amazon SimpleDB that has separation of interfaces. From the low level HTTP request access to high level Ruby abstraction ORM.}
+    gem.email = "jtarchie@gmail.com"
+    gem.homepage = "http://github.com/jtarchie/simplydb"
+    gem.authors = ["JT Archie"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency "typhoeus", ">= 0.1.27"
+    gem.add_dependency "nokogiri", ">= 1.4.2"
+    gem.add_dependency "uuidtools", ">= 2.1.1"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+desc "irb loaded with SimplyDB (rubygems not required)"
+task :irb do
+  exec("irb -I lib/ -r 'simplydb' -r 'simplydb/record/base'")
+end
+task :console => :irb
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simplydb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/examples/interface.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'simplydb'
+
+interface = SimplyDB::Interface.new({
+  :access_key => ENV['AWS_ACCESS_KEY'],
+  :secret_key => ENV['AWS_SECRET_KEY']
+})
+
+if interface.create_domain("MyDomain")
+  interface.put_attributes('MyDomain', 'Item123', {'color'=>['red','brick','garnet']})
+
+  attributes = interface.get_attributes('MyDomain', 'Item123')
+  puts "Item123 = #{attributes.inspect}"
+
+  items = interface.select("select color from MyDomain where color = 'brick'")
+  puts "Items = #{items.inspect}"
+
+  interface.delete_domain("MyDomain")
+end

data/examples/record.rb

@@ -0,0 +1,38 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'simplydb'
+require 'simplydb/record/base'
+
+SimplyDB::Record::Base.establish_connection({
+  'access_key' => ENV['AWS_ACCESS_KEY'],
+  'secret_key' => ENV['AWS_SECRET_KEY']
+})
+
+class MyDomain < SimplyDB::Record::Base; end
+
+MyDomain.create_domain
+
+puts "domain name: #{MyDomain.domain_name}"
+puts "domain exists?: #{MyDomain.domain_exists?}"
+
+model = MyDomain.new(
+  :name => 'JT Archie',
+  :age => 27
+)
+puts "attribues: #{model.attributes.inspect}"
+model[:age] = 29
+puts "attribues: #{model.attributes.inspect}"
+
+puts "model.new_record?: #{model.new_record?}"
+
+model.item_name = "Testing"
+puts "save: #{model.save}"
+
+sleep 2 #let SimpleDB propogate data (not supporting consistant read, yet)
+
+got_model = MyDomain.find('Testing')
+puts "got_model: #{got_model.attributes.inspect}"
+
+models = MyDomain.find_by_select('SELECT * FROM my_domain')
+puts "models: #{models.inspect}"
+
+#MyDomain.delete_domain

data/lib/simplydb/client.rb

@@ -0,0 +1,66 @@
+require 'openssl'
+require 'digest/sha1'
+require 'base64'
+require 'uri'
+require 'simplydb/clients/typhoeus'
+
+module SimplyDB
+  class Client
+    include SimplyDB::Extensions
+    
+    attr_accessor :options, :http_client
+    
+    def initialize(options = {})
+      @options = {
+        :async => false,
+        :protocol => 'https://',
+        :host => 'sdb.amazonaws.com',
+        :port => 443,
+        :path => "/",
+        :signature_version => '2',
+        :version => '2009-04-15',
+        :signature_method => 'HmacSHA256',
+      }.merge(options)
+      @http_client = (@options[:client] || SimplyDB::Clients::Typhoeus).new(options)
+    end
+    
+    def async?
+      return options[:async] == true
+    end
+    
+    def base_url
+      "#{@options[:protocol]}#{@options[:host]}:#{@options[:port]}#{@options[:path]}"
+    end
+    
+    def string_to_sign(method, params)
+      return "#{method.to_s.upcase}\n#{options[:host]}\n/\n" + escape_hash(params)
+    end
+    
+    def generate_signature(method, params)
+      Base64.encode64(
+        OpenSSL::HMAC.digest(
+          OpenSSL::Digest::Digest.new('sha256'),
+          @options[:secret_key],
+          string_to_sign(method, params)
+        )
+      ).chomp
+    end
+    
+    def params_with_signature(method, params)
+      params.merge!({
+        'AWSAccessKeyId' => @options[:access_key],
+        'SignatureVersion' => @options[:signature_version],
+        'Timestamp' => Time.now.iso8601,
+        'Version' => @options[:version],
+        'SignatureMethod' => @options[:signature_method]
+      })
+      params['Signature'] = generate_signature(method, params)
+      return params
+    end
+    
+    def call(method, params ={}, &on_complete)
+      options = {:method => method, :url => base_url, :params => params_with_signature(method, params)}
+      @http_client.request(options, !async?) {|request| on_complete.call(request.body)}
+    end
+  end
+end

data/lib/simplydb/clients/typhoeus.rb

@@ -0,0 +1,35 @@
+require 'typhoeus'
+
+module SimplyDB
+  module Clients
+    class Typhoeus
+      
+      attr_accessor :hydra, :options
+      
+      def initialize(options = {})
+        @options = options
+        @hydra = ::Typhoeus::Hydra.new
+      end
+      
+      def request(options={}, force = true, &block)
+        request = ::Typhoeus::Request.new(options[:url],
+          :method => options[:method],
+          :params => options[:params]
+        )
+        
+        @hydra.queue(request)
+        
+        unless force
+          request.on_complete {|response| block.call(response)}
+        else
+          @hydra.run
+          block.call(request.response)
+        end
+      end
+      
+      def run!
+        @hydra.run
+      end
+    end
+  end
+end

data/lib/simplydb/error.rb

@@ -0,0 +1,60 @@
+module SimplyDB
+  module Error
+    # ref http://docs.amazonwebservices.com/AmazonSimpleDB/latest/DeveloperGuide/APIError.html
+    class AccessFailure < RuntimeError; end
+    class AttributeDoesNotExist < RuntimeError; end
+    class AuthFailure < RuntimeError; end
+    class AuthMissingFailure < RuntimeError; end
+    class ConditionalCheckFailed < RuntimeError; end
+    class ExistsAndExpectedValue < RuntimeError; end
+    class FeatureDeprecated < RuntimeError; end
+    class IncompleteExpectedExpression < RuntimeError; end
+    class InternalError < RuntimeError; end
+    class InvalidAction < RuntimeError; end
+    class InvalidHTTPAuthHeader < RuntimeError; end
+    class InvalidHttpRequest < RuntimeError; end
+    class InvalidLiteral < RuntimeError; end
+    class InvalidNextToken < RuntimeError; end
+    class InvalidNumberPredicates < RuntimeError; end
+    class InvalidNumberValueTests < RuntimeError; end
+    class InvalidParameterCombination < RuntimeError; end
+    class InvalidParameterValue < RuntimeError; end
+    class InvalidQueryExpression < RuntimeError; end
+    class InvalidResponseGroups < RuntimeError; end
+    class InvalidService < RuntimeError; end
+    class InvalidSOAPRequest < RuntimeError; end
+    class InvalidSortExpression < RuntimeError; end
+    class InvalidURI < RuntimeError; end
+    class InvalidWSAddressingProperty < RuntimeError; end
+    class InvalidWSDLVersion < RuntimeError; end
+    class MalformedSOAPSignature < RuntimeError; end
+    class MissingAction < RuntimeError; end
+    class MissingParameter < RuntimeError; end
+    class MissingWSAddressingProperty < RuntimeError; end
+    class MultipleExistsConditions < RuntimeError; end
+    class MultipleExpectedNames < RuntimeError; end
+    class MultipleExpectedValues < RuntimeError; end
+    class MultiValuedAttribute < RuntimeError; end
+    class NoSuchDomain < RuntimeError; end
+    class NoSuchVersion < RuntimeError; end
+    class NotYetImplemented < RuntimeError; end
+    class NumberDomainsExceeded < RuntimeError; end
+    class NumberDomainAttributesExceeded < RuntimeError; end
+    class NumberDomainBytesExceeded < RuntimeError; end
+    class NumberItemAttributesExceeded < RuntimeError; end
+    class NumberSubmittedAttributesExceeded < RuntimeError; end
+    class NumberSubmittedItemsExceeded < RuntimeError; end
+    class RequestExpired < RuntimeError; end
+    class RequestTimeout < RuntimeError; end
+    class ServiceUnavailable < RuntimeError; end
+    class TooManyRequestedAttributes < RuntimeError; end
+    class UnsupportedHttpVerb < RuntimeError; end
+    class UnsupportedNextToken < RuntimeError; end
+    class URITooLong < RuntimeError; end
+  
+    #Standard AWS errors
+    class SignatureDoesNotMatch < RuntimeError; end
+    class InvalidClientTokenId < RuntimeError; end
+    class InvalidRequest < RuntimeError; end
+  end
+end

data/lib/simplydb/extensions.rb

@@ -0,0 +1,21 @@
+module SimplyDB
+  module Extensions
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+    
+    def escape_value(string)
+      string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
+        '%' + $1.unpack('H2' * $1.size).join('%').upcase
+      end.gsub(' ', '%20')
+    end
+    
+    def escape_hash(params = {})
+      return params.collect{|k,v| [k.to_s, v.to_s]}.sort.collect { |key, value| [escape_value(key), escape_value(value)].join('=') }.join('&')
+    end
+  end
+end

data/lib/simplydb/interface.rb

@@ -0,0 +1,207 @@
+require 'nokogiri'
+
+module SimplyDB
+  class Interface
+    attr_accessor :options, :client, :request_id, :box_usage, :next_token, :on_error
+    def initialize(options = {})
+      @options = {}.merge(options)
+      @client = SimplyDB::Client.new(options)
+    end
+    
+    def create_domain(name, &block)
+      call({'Action' => 'CreateDomain', 'DomainName' => name}) do |doc|
+        ret_val = doc.css("CreateDomainResponse").length > 0
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    def delete_domain(name, &block)
+      call({'Action' => 'DeleteDomain', 'DomainName' => name}) do |doc|
+        ret_val = doc.css("DeleteDomainResponse").length > 0
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    def list_domains(&block)
+      call({'Action' => 'ListDomains'}) do |doc|
+        domains = doc.css('DomainName').collect{|d| d.text}
+        block.call(domains) if block_given?
+        domains
+      end
+    end
+    
+    def domain_metadata(name, &block)
+      call({'Action' => 'DomainMetadata','DomainName' => name}) do |doc|
+        attributes = doc.css("DomainMetadataResult").first.children.inject({}) do |memo, child|
+          memo[child.name] = child.text
+          memo
+        end
+        block.call(attributes) if block_given?
+        attributes
+      end
+    end
+    
+    def put_attributes(name, id, attributes = {}, expected = {}, replace = false, &block)
+      params = define_attributes(attributes, expected, replace)
+      params.merge!({
+        'DomainName' => name,
+        'ItemName' => id,
+        'Action' => 'PutAttributes'
+      })
+      call(params) do |doc|
+        ret_val = doc.css("PutAttributesResponse").length > 0
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    def batch_put_attributes(name, items = {}, &block)
+      params = {'DomainName' => name, 'ActionName' => 'BatchPutAttributes'}
+      items.keys.each_with_index do |key, i|
+        params["Item.#{i}.ItemName"] = key
+        items[key].inject(0) do |j, (name,value)|
+          value = [value] unless value.is_a?(Array)
+          value.each do |v|
+            params["Item.#{i}.Attribute.#{j}.Name"] = name
+            params["Item.#{i}.Attribute.#{j}.Value"] = value
+            j+=1
+          end
+          j
+        end
+      end
+      call(params) do |doc|
+        ret_val = doc.css("BatchPutAttributesResponse").length > 0
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    def delete_attributes(name, id, attributes = {}, expected = {}, &block)
+      params = define_attributes(attributes, expected)
+      params.merge!({
+        'DomainName' => name,
+        'ItemName' => id,
+        'Action' => 'DeleteAttributes'
+      })
+      call(params) do |doc|
+        ret_val = doc.css("DeleteAttributesResponse").length > 0
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    def get_attributes(name, id, wanted_attributes = [], consistent_read = false, &block)
+      params = {
+        'Action' => 'GetAttributes',
+        'DomainName' => name,
+        'ItemName' => id,
+        'ConsistentRead' => consistent_read.to_s, 
+      }
+      wanted_attributes.each_with_index {|name, index| params["AttributeName.#{index}"] = name}
+
+      call(params) do |doc|
+        attributes = doc.css("Attribute").inject({}) do |memo, attribute|
+          name = attribute.css("Name").first.text
+          value = attribute.css("Value").first.text
+          if memo.has_key?(name)
+            memo[name] = [memo[name]] unless memo[name].is_a?(Array)
+            memo[name] << value
+          else
+            memo[name] = value
+          end
+          memo
+        end
+        block.call(attributes) if block_given?
+        attributes
+      end
+    end
+    
+    def select(expression, consistent_read = false, next_token = nil, &block)
+      params = {
+        'Action' => 'Select',
+        'SelectExpression' => expression,
+        'ConsistentRead' => consistent_read.to_s,
+      }
+      params['NextToken'] = next_token unless next_token.nil?
+      call(params) do |doc|
+        ret_val = doc.css("SelectResponse SelectResult Item").inject({}) do |items, item|
+          item_name = item.css("Name").first.text
+          items[item_name] = item.css("Attribute").inject({}) do |attributes, attribute|
+            attribute_name = attribute.css("Name").first.text
+            attribute_value = attribute.css("Value").first.text
+            if attributes.has_key?(attribute_name)
+              attributes[attribute_name] = [attributes[attribute_name]] unless attributes[attribute_name].is_a?(Array)
+              attributes[attribute_name] << attribute_value
+            else
+              attributes[attribute_name] = attribute_value
+            end
+            attributes
+          end
+          items
+        end
+        block.call(ret_val) if block_given?
+        ret_val
+      end
+    end
+    
+    private
+      def define_attributes(attributes = {}, expected = {}, replace = false)
+        params = {}
+        attributes.sort.inject(0) do |index, (k,v)|
+          v = [v] unless v.is_a?(Array)
+          v.each do |value|
+            params["Attribute.#{index}.Name"] = k
+            params["Attribute.#{index}.Value"] = value
+            params["Attribute.#{index}.Replace"] = "1" if replace
+            index += 1
+          end
+          index
+        end
+        expected.sort.inject(0) {|index, (k,v)|
+          case v
+            when Array
+              v.each do |value|
+                params["Expected.#{index}.Name"] = k
+                params["Expected.#{index}.Value"] = value
+                index += 1
+              end
+            when :exists
+              params["Expected.#{index}.Name"] = k
+              params["Expected.#{index}.Exists"] = v
+              index += 1
+            else
+              params["Expected.#{index}.Name"] = k
+              params["Expected.#{index}.Value"] = v
+              index += 1
+          end
+          index
+        }
+        return params
+      end
+      
+      def call(params = {}, attempts = 3, &block)
+        @client.call(:post, params) do |body|
+          begin
+            doc = Nokogiri::XML(body)
+            if error = doc.css("Response Errors Error").first
+              raise SimplyDB::Error.const_get(error.css("Code").first.content), error.css("Message").first.content
+            else
+              #gather some stats from the request
+              @request_id = doc.css("RequestId").first.text
+              @box_usage = doc.css("BoxUsage").first.text.to_f
+              @next_token = doc.css("NextToken").first.text unless doc.css("NextToken").empty?
+              block.call(doc)
+            end
+          rescue SimplyDB::Error::ServiceUnavailable => e
+            if attempts > 0
+              call(params, attempts - 1, &block)
+            else
+              raise
+            end
+          end
+        end
+      end
+  end
+end