aws-sdb 0.1.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2007, 2008 Tim Dysinger
+
+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

@@ -0,0 +1 @@
+Amazon SDB API

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+
+Spec::Rake::SpecTask.new
+
+gem_spec = Gem::Specification.new do |s|
+  s.name = "aws-sdb"
+  s.version = "0.1.0"
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.summary = "Amazon SDB API"
+  s.description = s.summary
+  s.author = "Tim Dysinger"
+  s.email = "tim@dysinger.net"
+  s.homepage = "http://dysinger.net"
+  s.add_dependency "needle"
+  s.require_path = 'lib'
+  s.autorequire = s.name.gsub('-','/')
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(gem_spec) do |pkg|
+  pkg.gem_spec = gem_spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{gem_spec.name}-#{gem_spec.version}}
+end

data/lib/aws_sdb.rb

@@ -0,0 +1,23 @@
+# require needle
+require 'rubygems'
+require 'needle'
+
+# require modules
+require 'aws_sdb/error'
+require 'aws_sdb/service'
+
+module AwsSdb
+
+  def self.container
+    @@container ||= Needle::Registry.new(
+      :logs => { :filename => "aws_sdb.log" }
+    ).namespace!(:aws_sdb) do
+      
+      service(:model => :multiton) do | c, p, access, secret |
+        Service.new(c.log_for(p), access, secret)
+      end
+      
+    end
+  end
+  
+end

data/lib/aws_sdb/error.rb

@@ -0,0 +1,40 @@
+module AwsSdb
+
+  class Error < RuntimeError ; end
+  
+  class RequestError < Error
+    attr_reader :request_id
+    
+    def initialize(message, request_id=nil)
+      super(message)
+      @request_id = request_id
+    end
+  end
+    
+  class InvalidDomainNameError < RequestError ; end
+  class InvalidParameterValueError < RequestError ; end
+  class InvalidNextTokenError < RequestError ; end
+  class InvalidNumberPredicatesError < RequestError ; end
+  class InvalidNumberValueTestsError < RequestError ; end
+  class InvalidQueryExpressionError < RequestError ; end
+  class MissingParameterError < RequestError ; end
+  class NoSuchDomainError < RequestError ; end
+  class NumberDomainsExceededError < RequestError ; end
+  class NumberDomainAttributesExceededError < RequestError ; end
+  class NumberDomainBytesExceededError < RequestErrror ; end
+  class NumberItemAttributesExceededError < RequestError ; end
+  class RequestTimeoutError < RequestError ; end
+  
+  class ConnectionError < Error
+    attr_reader :response
+      
+    def initialize(response)
+      super(
+        "#{response.code} \
+         #{response.message if response.respond_to?(:message)}"
+      )
+      @response = response
+    end
+  end
+  
+end

data/lib/aws_sdb/service.rb

@@ -0,0 +1,160 @@
+require 'time'
+require 'cgi'
+require 'uri'
+require 'net/http'
+
+require 'base64'
+require 'openssl'
+
+require 'rexml/document'
+require 'rexml/xpath'
+
+module AwsSdb
+    
+  class Service
+    def initialize(logger, access_key_id, secret_access_key)
+      @logger = logger
+      @access_key_id = access_key_id 
+      @secret_access_key = secret_access_key
+    end
+    
+    # TODO Make this options hash not a param list
+    def list_domains(max = nil, token = nil)
+      params = { 'Action' => 'ListDomains' }
+      params['MoreToken'] = 
+        token unless token.nil? || token.empty?
+      params['MaxResults'] = 
+        max.to_s unless max.nil? || max.to_i == 0
+      doc = call(:get, params)
+      results = []
+      REXML::XPath.each(doc, '//DomainName/text()') do |domain| 
+        results << domain.to_s
+      end
+      return results, REXML::XPath.each(doc, '/MoreToken/text()').to_s 
+    end
+        
+    def create_domain(domain)
+      call(:post, { 'Action' => 'CreateDomain', 'DomainName'=> domain.to_s })
+      nil
+    end
+  
+    def delete_domain(domain)
+      call(
+        :delete, 
+        { 'Action' => 'DeleteDomain', 'DomainName' => domain.to_s }
+      )
+      nil
+    end  
+    
+    def query(domain, query, sort = nil, max = nil, token = nil)
+      params = { 
+        'Action' => 'Query', 
+        'QueryExpression' => query,
+        'DomainName' => domain.to_s 
+      }
+      params['Sort'] = sort unless sort.nil? || sort.empty?
+      params['MoreToken'] = 
+        token unless token.nil? || token.empty?
+      params['MaxResults'] = 
+        max.to_s unless max.nil? || max.to_i != 0
+      doc = call(:get, params)
+      results = []
+      REXML::XPath.each(doc, '//ItemName/text()') do |item| 
+        results << item.to_s
+      end
+      return results, REXML::XPath.each(doc, '/MoreToken/text()').to_s 
+    end
+    
+    def put_attributes(domain, item, attributes, replace = true)
+      params = { 
+        'Action' => 'PutAttributes', 
+        'DomainName' => domain.to_s,
+        'ItemName' => item.to_s,
+        'Replace' => replace
+      }
+      count = 0
+      attributes.each do | key, values | 
+        ([]<<values).flatten.each do |value|
+          params["Attribute.#{count}.Name"] = key.to_s
+          params["Attribute.#{count}.Value"] = value.to_s
+          count += 1
+        end
+      end
+      call(:put, params)
+      nil
+    end
+        
+    def get_attributes(domain, item)
+      doc = call( 
+        :get, 
+        { 
+          'Action' => 'GetAttributes', 
+          'DomainName' => domain.to_s,
+          'ItemName' => item.to_s 
+        } 
+      )
+      attributes = {}
+      REXML::XPath.each(doc, "//Attribute") do |attr|
+        key = REXML::XPath.first(attr, './Name/text()').to_s
+        value = REXML::XPath.first(attr, './Value/text()').to_s
+        ( attributes[key] ||= [] ) << value
+      end
+      attributes
+    end
+
+    def delete_attributes(domain, item)
+      call( 
+        :delete, 
+        { 
+          'Action' => 'DeleteAttributes', 
+          'DomainName' => domain.to_s,
+          'ItemName' => item.to_s 
+        } 
+      )
+      nil
+    end
+
+    protected
+    
+    def call(method, params)   
+      params.merge!( { 
+          'Version' => '2007-02-09',
+          'SignatureVersion' => '1',
+          'AWSAccessKeyId' => @access_key_id,
+          'Timestamp' => Time.now.gmtime.iso8601
+        } 
+      )
+      data = ''
+      query = []
+      params.keys.sort_by { |k| k.upcase }.each do |key|
+        data << "#{key}#{params[key].to_s}"
+        query << "#{key}=#{CGI::escape(params[key].to_s)}"
+      end
+      digest = OpenSSL::Digest::Digest.new('sha1')
+      hmac = OpenSSL::HMAC.digest(digest, @secret_access_key, data)
+      signature = Base64.encode64(hmac).strip
+      query << "Signature=#{CGI::escape(signature)}"
+      query = query.join('&')
+      url = "http://sds.amazonaws.com?#{query}"
+      uri = URI.parse(url)
+      response = 
+        Net::HTTP.new(uri.host, uri.port).send_request(method, url)
+      @logger.debug("#{url} #{response.code} #{response.body}")
+      raise(ConnectionError.new(response)) unless (200..400).include?(
+        response.code.to_i
+      )
+      doc = REXML::Document.new(response.body)
+      error = doc.get_elements('*/Errors/Error')[0]
+      raise(
+        Module.class_eval(
+          "AwsSdb::#{error.get_elements('Code')[0].text}Error"
+        ).new(
+          error.get_elements('Message')[0].text,
+          doc.get_elements('*/RequestID')[0].text
+        ) 
+      ) unless error.nil?
+      doc
+    end
+  end
+
+end

data/spec/aws_sdb/service_spec.rb

@@ -0,0 +1,399 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+require 'digest/sha1'
+require 'net/http'
+require 'rexml/document'
+
+require 'rubygems'
+require 'uuidtools'
+
+include AwsSdb
+
+describe Service, "when creating a new domain" do
+  before(:all) do
+    @logger = AwsSdb.container.logs.get(:rspec)
+    @service = AwsSdb.container.service(
+      ENV['AMAZON_ACCESS_KEY_ID'],
+      ENV['AMAZON_SECRET_ACCESS_KEY']
+    )
+    @domain = "test-#{UUID.random_create.to_s}"
+    #    domains = @service.list_domains[0]
+    #    @logger.debug("Domains #{domains.inspect}")
+    #    domains.each do |d|
+    #      @service.delete_domain(d)
+    #    end
+  end
+
+  after(:all) do
+    #    @service.delete_domain(@domain)
+  end
+
+  def stub_success
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <CreateDomainResponse>
+        <ResponseStatus>
+          <StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage>0.001</BoxUsage>
+        </ResponseStatus>
+      </CreateDomainResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+  end
+
+  def stub_error(code, type, message)
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return(code)
+    resp.stub!(:body).and_return(
+      """
+      <Response>
+        <Errors>
+          <Error>
+            <Code>#{type}</Code>
+            <Message>#{message}</Message>
+          </Error>
+        </Errors>
+        <RequestID>#{UUID.random_create.to_s}</RequestID>
+      </Response>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+  end
+  
+  it "should not raise an error if a valid new domain name is given" do
+    stub_success
+    lambda {
+      @service.create_domain("test-#{UUID.random_create.to_s}")
+    }.should_not raise_error
+  end
+  
+  it "should not raise an error if the domain name already exists" do
+    stub_success
+    domain = "test-#{UUID.random_create.to_s}"
+    lambda {
+      @service.create_domain(domain)
+      @service.create_domain(domain)
+    }.should_not raise_error
+  end
+  
+  it "should raise an error if an a nil or '' domain name is given" do
+    stub_error(
+      400, :InvalidDomainName, "The domain name '' is not valid."
+    )
+    lambda { 
+      @service.create_domain('') 
+    }.should raise_error(InvalidDomainNameError)
+    stub_error(
+      400, :InvalidDomainName, "The domain name '     ' is not valid."
+    )
+    lambda { 
+      @service.create_domain('     ')
+    }.should raise_error(InvalidDomainNameError)
+    stub_error(
+      400, :InvalidDomainName, "The domain name '' is not valid."
+    )
+    lambda { 
+      @service.create_domain(nil)
+    }.should raise_error(InvalidDomainNameError)
+  end
+
+  it "should raise an error if the domain name length is < 3 or > 255" do
+    stub_error(
+      400, :InvalidDomainName, "The domain name 'xx' is not valid."
+    )
+    lambda { 
+      @service.create_domain('xx')
+    }.should raise_error(InvalidDomainNameError)
+    stub_error(
+      400, 
+      :InvalidDomainName, 
+      "The domain name '#{:x.to_s*256}' is not valid."
+    )
+    lambda { 
+      @service.create_domain('x'*256)
+    }.should raise_error(InvalidDomainNameError)
+  end
+
+  it "should only accept domain names with a-z, A-Z, 0-9, '_', '-', and '.' " do
+    stub_error(
+      400, :InvalidDomainName, "The domain name '@$^*()' is not valid."
+    )
+    lambda { 
+      @service.create_domain('@$^&*()')
+    }.should raise_error(InvalidDomainNameError)
+  end
+
+  it "should only accept a maximum of 100 domain names" do
+    # TODO Implement this example
+  end
+
+  it "should not have to call amazon to determine domain name correctness" do
+    # TODO Implement this example
+  end
+end
+
+describe Service, "when listing domains" do
+  before(:all) do
+    @service = AwsSdb.container.service(
+      ENV['AMAZON_ACCESS_KEY_ID'],
+      ENV['AMAZON_SECRET_ACCESS_KEY']
+    )
+    @domain = "test-#{UUID.random_create.to_s}"
+    #    @service.list_domains[0].each do |d|
+    #      @service.delete_domain(d)
+    #    end
+    #    @service.create_domain(@domain)
+  end
+
+  after(:all) do
+    #    @service.delete_domain(@domain)
+  end
+
+  it "should return a complete list" do
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <ListDomainsResponse>
+        <ResponseStatus>
+          <StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage/>
+        </ResponseStatus>
+        <DomainName>#{@domain}</DomainName>
+      </ListDomainsResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+    
+    result = nil
+    lambda { result = @service.list_domains[0] }.should_not raise_error    
+    result.should_not be_nil 
+    result.should_not be_empty
+    result.size.should == 1
+    result.should_not be_nil
+    result.include?(@domain).should == true
+  end
+end
+
+describe Service, "when deleting domains" do
+  before(:all) do
+    @service = AwsSdb.container.service(
+      ENV['AMAZON_ACCESS_KEY_ID'],
+      ENV['AMAZON_SECRET_ACCESS_KEY']
+    )
+    @domain = "test-#{UUID.random_create.to_s}"
+    #    @service.list_domains[0].each do |d|
+    #      @service.delete_domain(d)
+    #    end
+    #    @service.create_domain(@domain)
+  end
+  
+  after do
+    #    @service.delete_domain(@domain)
+  end
+  
+  def stub_success
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <DeleteDomainResponse>
+        <ResponseStatus>
+           <StatusCode>Success</StatusCode>
+           <RequestID>#{UUID.random_create.to_s}</RequestID>
+           <BoxUsage/>
+        </ResponseStatus>
+      </DeleteDomainResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+  end
+
+  it "should be able to delete an existing domain" do
+    stub_success
+    lambda { @service.delete_domain(@domain) }.should_not raise_error
+  end
+   
+  it "should not raise an error trying to delete a non-existing domain" do
+    stub_success
+    lambda { 
+      @service.delete_domain(UUID.random_create.to_s) 
+    }.should_not raise_error
+  end
+end
+
+describe Service, "when managing items" do
+  before(:all) do
+    @service = AwsSdb.container.service(
+      ENV['AMAZON_ACCESS_KEY_ID'],
+      ENV['AMAZON_SECRET_ACCESS_KEY']
+    )
+    @domain = "test-#{UUID.random_create.to_s}"
+#    @service.list_domains[0].each do |d|
+#      @service.delete_domain(d)
+#    end
+#    @service.create_domain(@domain)
+    @item = "test-#{UUID.random_create.to_s}"
+    @attributes = {
+      :question => 'What is the answer?',
+      :answer => [ true, 'testing123', 4.2, 42, 420 ]
+    }
+  end
+  
+  after(:all) do
+#    @service.delete_domain(@domain)
+  end
+  
+  def stub_put
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <PutAttributesResponse>
+        <ResponseStatus><StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage/>
+        </ResponseStatus>
+      </PutAttributesResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)    
+  end
+  
+  def stub_get
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <GetAttributesResponse>
+        <ResponseStatus>
+          <StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage/>
+        </ResponseStatus>
+        <Attribute>
+          <Name>question</Name>
+          <Value>What is the answer?</Value>
+        </Attribute>
+        <Attribute>
+          <Name>answer</Name>
+          <Value>true</Value>
+        </Attribute>
+        <Attribute>
+          <Name>answer</Name>
+          <Value>testing123</Value>
+        </Attribute>
+        <Attribute>
+          <Name>answer</Name>
+          <Value>4.2</Value>
+        </Attribute>
+        <Attribute>
+          <Name>answer</Name>
+          <Value>42</Value>
+        </Attribute>
+        <Attribute>
+          <Name>answer</Name>
+          <Value>420</Value>
+        </Attribute>
+      </GetAttributesResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)    
+  end
+  
+  def stub_query
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <QueryResponse>
+        <ResponseStatus>
+          <StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage/>
+        </ResponseStatus>
+        <ItemName>#{@item}</ItemName>
+      </QueryResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+  end
+  
+  def stub_delete
+    resp = mock(Net::HTTPResponse)
+    resp.stub!(:code).and_return("200")
+    resp.stub!(:body).and_return(
+      """
+      <DeleteAttributesResponse>
+        <ResponseStatus>
+          <StatusCode>Success</StatusCode>
+          <RequestID>#{UUID.random_create.to_s}</RequestID>
+          <BoxUsage/>
+        </ResponseStatus>
+      </DeleteAttributesResponse>
+      """
+    )
+    http = mock(Net::HTTP)
+    http.stub!(:send_request).and_return(resp)
+    Net::HTTP.stub!(:new).and_return(http)
+  end
+  
+  it "should be able to put attributes" do
+    stub_put
+    lambda {
+      @service.put_attributes(@domain, @item, @attributes)
+    }.should_not raise_error
+  end
+
+  it "should be able to get attributes" do 
+    stub_get
+    result = nil
+    lambda {
+      result = @service.get_attributes(@domain, @item)
+    }.should_not raise_error
+    result.should_not be_nil
+    result.should_not be_empty
+    result.has_key?('answer').should == true
+    @attributes[:answer].each do |v|
+      result['answer'].include?(v.to_s).should == true
+    end
+  end
+
+  it "should be able to query" do
+    stub_query
+    result = nil
+    lambda {
+      result = @service.query(@domain, "[ 'answer' = '42' ]")[0]
+    }.should_not raise_error
+    result.should_not be_nil
+    result.should_not be_empty
+    result.should_not be_nil
+    result.include?(@item).should == true
+  end
+
+  it "should be able to delete attributes" do
+    stub_delete
+    lambda {
+      @service.delete_attributes(@domain, @item)
+    }.should_not raise_error
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'aws_sdb'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: aws-sdb
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tim Dysinger
+autorequire: aws/sdb
+bindir: bin
+cert_chain: []
+
+date: 2008-01-03 00:00:00 -10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: needle
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Amazon SDB API
+email: tim@dysinger.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/aws_sdb
+- lib/aws_sdb/error.rb
+- lib/aws_sdb/service.rb
+- lib/aws_sdb.rb
+- spec/aws_sdb
+- spec/aws_sdb/service_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://dysinger.net
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Amazon SDB API
+test_files: []
+