Parent

Class/Module Index [+]

Quicksearch

Rudy::AWS::SDB

Public Class Methods

generate_select(domain, fields={}) click to toggle source

Takes a Hash of criteria. Returns a string suitable for a SimpleDB Select

# File lib/rudy/aws/sdb.rb, line 67
def self.generate_select(domain, fields={})
  query = []
  fields.each_pair do |n,v| 
    query << "#{Rudy::AWS.escape n}='#{Rudy::AWS.escape v}'"
  end
  str = "select * from #{domain} " 
  str << " where "<< query.join(' and ') unless query.empty?
  str
end
new(access_key=nil, secret_key=nil, region=nil, debug=nil) click to toggle source
# File lib/rudy/aws/sdb.rb, line 19
def initialize(access_key=nil, secret_key=nil, region=nil, debug=nil)
  raise NoAccessKey if access_key.nil? || access_key.empty?
  raise NoSecretKey if secret_key.nil? || secret_key.empty?
    
  url ||= 'http://sdb.amazonaws.com'
  # There is a bug with passing :server to EC2::Base.new so 
  # we'll use the environment variable for now. 
  #if region && Rudy::AWS.valid_region?(region)
  #  "#{region}.sdb.amazonaws.com"
  #end
  
  @access_key_id = access_key || ENV['AWS_ACCESS_KEY']
  @secret_access_key = secret_key || ENV['AWS_SECRET_KEY']
  @base_url = url
  @debug = debug || StringIO.new
end

Public Instance Methods

create_domain(domain) click to toggle source
# File lib/rudy/aws/sdb.rb, line 51
def create_domain(domain)
  call(:post, { 'Action' => 'CreateDomain', 'DomainName'=> domain.to_s })
  true
end
delete_attributes(domain, item) click to toggle source
# File lib/rudy/aws/sdb.rb, line 159
def delete_attributes(domain, item)
  call(
    :delete,
    {
      'Action' => 'DeleteAttributes',
      'DomainName' => domain.to_s,
      'ItemName' => item.to_s
    }
  )
  true
end
Also aliased as: destroy
destroy(domain, item) click to toggle source
Alias for: delete_attributes
destroy_domain(domain) click to toggle source
# File lib/rudy/aws/sdb.rb, line 56
def destroy_domain(domain)
  call(
    :delete,
    { 'Action' => 'DeleteDomain', 'DomainName' => domain.to_s }
  )
  true
end
get(domain, item) click to toggle source
Alias for: get_attributes
get_attributes(domain, item) click to toggle source
# File lib/rudy/aws/sdb.rb, line 136
def get_attributes(domain, item)
  doc = call(
    :get,
    {
      'Action' => 'GetAttributes',
      'DomainName' => domain.to_s,
      'ItemName' => item.to_s
    }
  )
  attributes = {}
  if doc
    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
  end
  attributes = nil if attributes.empty?
  attributes
end
Also aliased as: get
list_domains(max = nil, token = nil) click to toggle source
# File lib/rudy/aws/sdb.rb, line 36
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
  results
end
put(domain, item, attributes, replace = true) click to toggle source
Alias for: put_attributes
put_attributes(domain, item, attributes, replace = true) click to toggle source
# File lib/rudy/aws/sdb.rb, line 112
def put_attributes(domain, item, attributes, replace = true)
  replace = true if replace == :replace
  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)
  
  true
end
Also aliased as: put
select(select, token = nil) click to toggle source
# File lib/rudy/aws/sdb.rb, line 78
def select(select, token = nil)
  params = {
    'Action' => 'Select',
    'SelectExpression' => select,
  }
  params['NextToken'] =
    token unless token.nil? || token.empty?
    
  doc = call(:get, params)
  results = []
  if doc
    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
  
  hash_results = {}
  results.each do |item|
    hash_results[item.delete('Name')] = item
  end
  
  hash_results.empty? ? nil : hash_results
end

Protected Instance Methods

call(method, params) click to toggle source
# File lib/rudy/aws/sdb.rb, line 204
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)
  
  #Rudy::Huxtable.ld url if Rudy.debug?
  
  response = execute_request(nil) {
    Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
  }
  
  if !response.nil?
  
    @debug.puts("#{response.code}\n#{response.body}") if @debug
    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(
        "Rudy::AWS::SDB::#{error.get_elements('Code')[0].text}Error"
      ).new(
        error.get_elements('Message')[0].text,
        doc.get_elements('*/RequestID')[0].text
      )
    ) unless error.nil?
  else
    doc = nil
  end
  doc
end
execute_request(default=nil, timeout=nil, &request) click to toggle source

Execute AWS requests safely. This will trap errors and return a default value (if specified).

  • default A default response value

  • request A block which contains the AWS request

Returns the return value from the request is returned untouched or the default value on error or if the request returned nil.

# File lib/rudy/aws/sdb.rb, line 183
def execute_request(default=nil, timeout=nil, &request)
  timeout ||= 30
  raise "No block provided" unless request
  response = nil
  begin
    Timeout::timeout(timeout) do
      response = request.call
    end

  rescue Timeout::Error => ex
    Rudy::Huxtable.le "Timeout (#{timeout}): #{ex.message}!"
  rescue SocketError => ex
    #Rudy::Huxtable.le ex.message
    #Rudy::Huxtable.le ex.backtrace
    raise SocketError, "Check your Internets!" unless Rudy::Huxtable.global.offline
  ensure
    response ||= default
  end
  response
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.