bguthrie-awsymandias 0.2.1 → 0.3.1

data/vendor/aws-sdb/LICENSE

@@ -1,19 +0,0 @@
-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/vendor/aws-sdb/README

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

data/vendor/aws-sdb/Rakefile

@@ -1,20 +0,0 @@
-require 'rubygems'
-require 'spec/rake/spectask'
-require 'rake/gempackagetask'
-
-Spec::Rake::SpecTask.new
-
-gem_spec = eval(IO.read(File.join(File.dirname(__FILE__), "aws-sdb.gemspec")))
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -I lib -r aws_sdb.rb"
-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/vendor/aws-sdb/lib/aws_sdb.rb

@@ -1,3 +0,0 @@
-require 'aws_sdb/error'
-require 'aws_sdb/service'
-

data/vendor/aws-sdb/lib/aws_sdb/error.rb

@@ -1,42 +0,0 @@
-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 < RequestError ; end
-  class NumberItemAttributesExceededError < RequestError ; end
-  class RequestTimeoutError < RequestError ; end
-
-  class FeatureDeprecatedError < 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/vendor/aws-sdb/lib/aws_sdb/service.rb

@@ -1,191 +0,0 @@
-require 'logger'
-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(options={})
-      @access_key_id = options[:access_key_id] || ENV['AMAZON_ACCESS_KEY_ID']
-      @secret_access_key = options[:secret_access_key] || ENV['AMAZON_SECRET_ACCESS_KEY']
-      @base_url = options[:url] || 'http://sdb.amazonaws.com'
-      @logger = options[:logger] || Logger.new("aws_sdb.log")
-    end
-
-    def list_domains(max = nil, token = nil)
-      params = { 'Action' => 'ListDomains' }
-      params['NextToken'] =
-        token unless token.nil? || token.empty?
-      params['MaxNumberOfDomains'] =
-        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.first(doc, '//NextToken/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
-    # <QueryWithAttributesResult><Item><Name>in-c2ffrw</Name><Attribute><Name>code</Name><Value>in-c2ffrw</Value></Attribute><Attribute><Name>date_created</Name><Value>2008-10-31</Value></Attribute></Item><Item>
-    def query_with_attributes(domain, query, max = nil, token = nil)
-      params = {
-        'Action' => 'QueryWithAttributes',
-        'QueryExpression' => query,
-        'DomainName' => domain.to_s
-      }
-      params['NextToken'] =
-        token unless token.nil? || token.empty?
-      params['MaxNumberOfItems'] =
-        max.to_s unless max.nil? || max.to_i == 0
-
-      doc = call(:get, params)
-      results = []
-      REXML::XPath.each(doc, "//Item") do |item|
-        name = REXML::XPath.first(item, './Name/text()').to_s
-
-
-        attributes = {'Name' => name}
-        REXML::XPath.each(item, "./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
-        results << attributes
-      end
-      return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
-    end
-
-    # <QueryResult><ItemName>in-c2ffrw</ItemName><ItemName>in-72yagt</ItemName><ItemName>in-52j8gj</ItemName>
-    def query(domain, query, max = nil, token = nil)
-      params = {
-        'Action' => 'Query',
-        'QueryExpression' => query,
-        'DomainName' => domain.to_s
-      }
-      params['NextToken'] =
-        token unless token.nil? || token.empty?
-      params['MaxNumberOfItems'] =
-        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.first(doc, '//NextToken/text()').to_s
-
-    end
-
-    def put_attributes(domain, item, attributes, replace = true)
-      params = {
-        'Action' => 'PutAttributes',
-        'DomainName' => domain.to_s,
-        'ItemName' => item.to_s
-      }
-      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
-          params["Attribute.#{count}.Replace"] = replace
-          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-11-07',
-          '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 = "#{@base_url}?#{query}"
-      uri = URI.parse(url)
-      @logger.debug("#{url}") if @logger
-      response =
-        Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
-      @logger.debug("#{response.code}\n#{response.body}") if @logger
-      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/vendor/aws-sdb/spec/aws_sdb/service_spec.rb

@@ -1,183 +0,0 @@
-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
-    @service = AwsSdb::Service.new
-    @domain = "test-#{UUID.random_create.to_s}"
-    domains = @service.list_domains[0]
-    domains.each do |d|
-      @service.delete_domain(d) if d =~ /^test/
-    end
-  end
-
-  after(:all) do
-    @service.delete_domain(@domain)
-  end
-
-  it "should not raise an error if a valid new domain name is given" do
-    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
-    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
-    lambda {
-      @service.create_domain('')
-    }.should raise_error(InvalidParameterValueError)
-    lambda {
-      @service.create_domain(nil)
-    }.should raise_error(InvalidParameterValueError)
-    lambda {
-      @service.create_domain('     ')
-    }.should raise_error(InvalidParameterValueError)
-  end
-
-  it "should raise an error if the domain name length is < 3 or > 255" do
-    lambda {
-      @service.create_domain('xx')
-    }.should raise_error(InvalidParameterValueError)
-    lambda {
-      @service.create_domain('x'*256)
-    }.should raise_error(InvalidParameterValueError)
-  end
-
-  it "should only accept domain names with a-z, A-Z, 0-9, '_', '-', and '.' " do
-    lambda {
-      @service.create_domain('@$^*()')
-    }.should raise_error(InvalidParameterValueError)
-  end
-
-  it "should only accept a maximum of 100 domain names"
-
-  it "should not have to call amazon to determine domain name correctness"
-end
-
-describe Service, "when listing domains" do
-  before(:all) do
-    @service = AwsSdb::Service.new
-    @domain = "test-#{UUID.random_create.to_s}"
-    @service.list_domains[0].each do |d|
-      @service.delete_domain(d) if d =~ /^test/
-    end
-    @service.create_domain(@domain)
-  end
-
-  after(:all) do
-    @service.delete_domain(@domain)
-  end
-
-  it "should return a complete list" do
-    result = nil
-    lambda { result = @service.list_domains[0] }.should_not raise_error
-    result.should_not be_nil
-    result.should_not be_empty
-    result.include?(@domain).should == true
-  end
-end
-
-describe Service, "when deleting domains" do
-  before(:all) do
-    @service = AwsSdb::Service.new
-    @domain = "test-#{UUID.random_create.to_s}"
-    @service.list_domains[0].each do |d|
-      @service.delete_domain(d) if d =~ /^test/
-    end
-    @service.create_domain(@domain)
-  end
-
-  after do
-    @service.delete_domain(@domain)
-  end
-
-  it "should be able to delete an existing domain" do
-    lambda { @service.delete_domain(@domain) }.should_not raise_error
-  end
-
-  it "should not raise an error trying to delete a non-existing domain" do
-    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::Service.new
-    @domain = "test-#{UUID.random_create.to_s}"
-    @service.list_domains[0].each do |d|
-      @service.delete_domain(d) if d =~ /^test/
-    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
-
-  it "should be able to put attributes" do
-    lambda {
-      @service.put_attributes(@domain, @item, @attributes)
-    }.should_not raise_error
-  end
-
-  it "should be able to get attributes" do
-    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
-    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 query with attributes"
-
-  it "should be able to delete attributes" do
-    lambda {
-      @service.delete_attributes(@domain, @item)
-    }.should_not raise_error
-  end
-end
-
-# TODO Pull the specs from the amazon docs and write more rspec
-# 100 attributes per each call
-# 256 total attribute name-value pairs per item
-# 250 million attributes per domain
-# 10 GB of total user data storage per domain
-# ...etc...