Class: RightAws::SdbInterface

Inherits:
RightAwsBase show all
Includes:
RightAwsBaseInterface
Defined in:
lib/sdb/right_sdb_interface.rb

Defined Under Namespace

Classes: QSdbGetAttributesParser, QSdbListDomainParser, QSdbQueryParser, QSdbSimpleParser

Constant Summary collapse

DEFAULT_HOST = 
'sdb.amazonaws.com'
DEFAULT_PORT = 
443
DEFAULT_PROTOCOL = 
'https'
API_VERSION = 
'2007-11-07'
DEFAULT_NIL_REPRESENTATION = 
'nil'
@@bench = 
AwsBenchmarkingBlock.new

Constants included from RightAwsBaseInterface

RightAwsBaseInterface::DEFAULT_SIGNATURE_VERSION

Constants inherited from RightAwsBase

RightAwsBase::AMAZON_PROBLEMS

Instance Attribute Summary collapse

Attributes included from RightAwsBaseInterface

#aws_access_key_id, #cache, #connection, #last_errors, #last_request, #last_request_id, #last_response, #logger, #params, #signature_version

Class Method Summary collapse

Instance Method Summary collapse

Methods included from RightAwsBaseInterface

#cache_hits?, caching, caching=, #caching?, #init, #multi_thread, #on_exception, #request_cache_or_info, #request_info_impl, #update_cache

Methods inherited from RightAwsBase

amazon_problems, amazon_problems=

Constructor Details

#initialize(aws_access_key_id = nil, aws_secret_access_key = nil, params = {}) ⇒ SdbInterface

Creates new RightSdb instance.

Params:

{ :server       => 'sdb.amazonaws.com'  # Amazon service host: 'sdb.amazonaws.com'(default)
  :port         => 443                  # Amazon service port: 80 or 443(default)
  :protocol     => 'https'              # Amazon service protocol: 'http' or 'https'(default)
  :signature_version => '0'             # The signature version : '0' or '1'(default)
  :multi_thread => true|false           # Multi-threaded (connection per each thread): true or false(default)
  :logger       => Logger Object        # Logger instance: logs to STDOUT if omitted 
  :nil_representation => 'mynil'}       # interpret Ruby nil as this string value; i.e. use this string in SDB to represent Ruby nils (default is the string 'nil')

Example:

sdb = RightAws::SdbInterface.new('1E3GDYEOGFJPIT7XXXXXX','hgTHt68JY07JKUY08ftHYtERkjgtfERn57XXXXXX', {:multi_thread => true, :logger => Logger.new('/tmp/x.log')}) #=> #<RightSdb:0xa6b8c27c>

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/sdb/right_sdb_interface.rb', line 61

def initialize(aws_access_key_id=nil, aws_secret_access_key=nil, params={})
  @nil_rep = params[:nil_representation] ? params[:nil_representation] : DEFAULT_NIL_REPRESENTATION
  params.delete(:nil_representation)
  init({ :name             => 'SDB', 
         :default_host     => ENV['SDB_URL'] ? URI.parse(ENV['SDB_URL']).host   : DEFAULT_HOST, 
         :default_port     => ENV['SDB_URL'] ? URI.parse(ENV['SDB_URL']).port   : DEFAULT_PORT, 
         :default_protocol => ENV['SDB_URL'] ? URI.parse(ENV['SDB_URL']).scheme : DEFAULT_PROTOCOL }, 
       aws_access_key_id     || ENV['AWS_ACCESS_KEY_ID'], 
       aws_secret_access_key || ENV['AWS_SECRET_ACCESS_KEY'], 
       params)
end

Instance Attribute Details

#last_query_expression ⇒ Object (readonly)

Returns the value of attribute last_query_expression.



42
43
44
 
# File 'lib/sdb/right_sdb_interface.rb', line 42

def last_query_expression
  @last_query_expression
end

Class Method Details

.bench_sdb ⇒ Object 



40
 
# File 'lib/sdb/right_sdb_interface.rb', line 40

def self.bench_sdb; @@bench.service; end

.bench_xml ⇒ Object 



39
 
# File 'lib/sdb/right_sdb_interface.rb', line 39

def self.bench_xml; @@bench.xml;     end

Instance Method Details

#create_domain(domain_name) ⇒ Object

Create new SDB domain at Amazon.

Returns a hash: { :box_usage, :request_id } on success or an exception on error. (Amazon raises no errors if the domain already exists).

Example:

sdb = RightAws::SdbInterface.new
sdb.create_domain('toys') # => { :box_usage  => "0.0000071759",
                                 :request_id => "976709f9-0111-2345-92cb-9ce90acd0982" }

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_CreateDomain.html



240
241
242
243
244
245
246
 
# File 'lib/sdb/right_sdb_interface.rb', line 240

def create_domain(domain_name)
  link = generate_request("CreateDomain",
                          'DomainName' => domain_name)
  request_info(link, QSdbSimpleParser.new)
rescue Exception
  on_exception
end

#delete_attributes(domain_name, item_name, attributes = nil) ⇒ Object

Delete value, attribute or item.

Example:

# delete 'vodka' and 'girls' from 'Jon' and 'mice' from 'cat'.
sdb.delete_attributes 'family', 'toys', { 'Jon' => ['vodka', 'girls'], 'cat' => ['mice'] }

# delete the all the values from attributes (i.e. delete the attributes)
sdb.delete_attributes 'family', 'toys', { 'Jon' => [], 'cat' => [] }
# or 
sdb.delete_attributes 'family', 'toys', [ 'Jon', 'cat' ]

# delete all the attributes from item 'toys' (i.e. delete the item)
sdb.delete_attributes 'family', 'toys'

see docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_DeleteAttributes.html



372
373
374
375
376
377
378
379
 
# File 'lib/sdb/right_sdb_interface.rb', line 372

def delete_attributes(domain_name, item_name, attributes = nil)
  params = { 'DomainName' => domain_name,
             'ItemName'   => item_name }.merge(pack_attributes(attributes))
  link = generate_request("DeleteAttributes", params)
  request_info( link, QSdbSimpleParser.new )
rescue Exception
  on_exception
end

#delete_domain(domain_name) ⇒ Object

Delete SDB domain at Amazon.

Returns a hash: { :box_usage, :request_id } on success or an exception on error. (Amazon raises no errors if the domain does not exist).

Example:

sdb = RightAws::SdbInterface.new
sdb.delete_domain('toys') # => { :box_usage  => "0.0000071759",
                                 :request_id => "976709f9-0111-2345-92cb-9ce90acd0982" }

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_DeleteDomain.html



261
262
263
264
265
266
267
 
# File 'lib/sdb/right_sdb_interface.rb', line 261

def delete_domain(domain_name)
  link = generate_request("DeleteDomain",
                          'DomainName' => domain_name)
  request_info(link, QSdbSimpleParser.new)
rescue Exception
  on_exception
end

#escape(value) ⇒ Object

Use this helper to manually escape the fields in the query expressions. To escape the single quotes and backslashes and to wrap the string into the single quotes.

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API.html



151
152
153
 
# File 'lib/sdb/right_sdb_interface.rb', line 151

def escape(value)
  %Q{'#{value.to_s.gsub(/(['\\])/){ "\\#{$1}" }}'} if value
end

#generate_request(action, params = {}) ⇒ Object 

Requests



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/sdb/right_sdb_interface.rb', line 76

def generate_request(action, params={}) #:nodoc:
  # remove empty params from request
  params.delete_if {|key,value| value.nil? }
  #params_string  = params.to_a.collect{|key,val| key + "=#{CGI::escape(val.to_s)}" }.join("&")
  # prepare service data
  service_hash = {"Action"            => action,
                  "AWSAccessKeyId"    => @aws_access_key_id,
                  "Version"           => API_VERSION,
                  "Timestamp"         => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S.000Z"),
                  "SignatureVersion"  => signature_version }
  service_hash.update(params)
  # prepare string to sight
  string_to_sign = case signature_version
                   when '0' then service_hash["Action"] + service_hash["Timestamp"]
                   when '1' then service_hash.sort{|a,b| (a[0].to_s.downcase)<=>(b[0].to_s.downcase)}.to_s
                   end
  service_hash.update('Signature' =>  AwsUtils::sign(@aws_secret_access_key, string_to_sign))
  service_string = service_hash.to_a.collect{|key,val| key + "=#{CGI::escape(val.to_s)}" }.join("&")
  #
  # use POST method if the length of the query string is too large
  # see http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/MakingRESTRequests.html
  if service_string.size > 2000
    request      = Net::HTTP::Post.new("/")
    request.body = service_string
  else
    #params_string = "&#{params_string}" unless params_string.blank?
    request       = Net::HTTP::Get.new("/?#{service_string}")
  end
  # prepare output hash
  { :request  => request, 
    :server   => @params[:server],
    :port     => @params[:port],
    :protocol => @params[:protocol] }
end

#get_attributes(domain_name, item_name, attribute_name = nil) ⇒ Object

Retrieve SDB item’s attribute(s).

Returns a hash:

{ :box_usage  => string,
  :request_id => string,
  :attributes => { 'nameA' => [valueA1,..., valueAN],
                   ... ,
                   'nameZ' => [valueZ1,..., valueZN] } }

Example:

# request all attributes
sdb.get_attributes('family', 'toys') # => { :attributes => {"cat"    => ["clew", "Jons_socks", "mouse"] },
                                                            "Silvia" => ["beetle", "rolling_pin", "kids"],
                                                            "Jon"    => ["vacuum_cleaner", "hammer", "spade"]},
                                            :box_usage  => "0.0000093222",
                                            :request_id => "81273d21-000-1111-b3f9-512d91d29ac8" }

# request cat's attributes only
sdb.get_attributes('family', 'toys', 'cat') # => { :attributes => {"cat" => ["clew", "Jons_socks", "mouse"] },
                                                   :box_usage  => "0.0000093222",
                                                   :request_id => "81273d21-001-1111-b3f9-512d91d29ac8" }

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_GetAttributes.html



343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/sdb/right_sdb_interface.rb', line 343

def get_attributes(domain_name, item_name, attribute_name=nil)
  link = generate_request("GetAttributes", 'DomainName'    => domain_name,
                                           'ItemName'      => item_name,
                                           'AttributeName' => attribute_name )
  res = request_info(link, QSdbGetAttributesParser.new)
  res[:attributes].each_value do |values|
    values.collect! { |e| sdb_to_ruby(e) }
  end
  res
rescue Exception
  on_exception
end

#list_domains(max_number_of_domains = nil, next_token = nil) ⇒ Object

Retrieve a list of SDB domains from Amazon.

Returns a hash:

{ :domains     => [domain1, ..., domainN],
  :next_token => string || nil,
  :box_usage   => string,
  :request_id  => string }

Example:

sdb = RightAws::SdbInterface.new
sdb.list_domains  #=> { :box_usage  => "0.0000071759",
                        :request_id => "976709f9-0111-2345-92cb-9ce90acd0982",
                        :domains    => ["toys", "dolls"]}

If a block is given, this method yields to it. If the block returns true, list_domains will continue looping the request. If the block returns false, list_domains will end.

sdb.list_domains(10) do |result|   # list by 10 domains per iteration
  puts result.inspect
  true
end

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_ListDomains.html



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/sdb/right_sdb_interface.rb', line 208

def list_domains(max_number_of_domains = nil, next_token = nil )
  request_params = { 'MaxNumberOfDomains' => max_number_of_domains,
                     'NextToken'          => next_token }
  link   = generate_request("ListDomains", request_params)
  result = request_info(link, QSdbListDomainParser.new)
  # return result if no block given
  return result unless block_given?
  # loop if block if given
  begin
    # the block must return true if it wanna continue 
    break unless yield(result) && result[:next_token]
    # make new request
    request_params['NextToken'] = result[:next_token]
    link   = generate_request("ListDomains", request_params)
    result = request_info(link, QSdbListDomainParser.new)
  end while true
rescue Exception
  on_exception
end

#pack_attributes(attributes, replace = false) ⇒ Object

Prepare attributes for putting. (used by put_attributes)



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/sdb/right_sdb_interface.rb', line 121

def pack_attributes(attributes, replace = false) #:nodoc:
  result = {}
  if attributes
    idx = 0
    skip_values = attributes.is_a?(Array)
    attributes.each do |attribute, values|
      # set replacement attribute
      result["Attribute.#{idx}.Replace"] = 'true' if replace
      # pack Name/Value
      unless values.nil?
        Array(values).each do |value|
          result["Attribute.#{idx}.Name"]  = attribute
          result["Attribute.#{idx}.Value"] = ruby_to_sdb(value) unless skip_values
          idx += 1
        end
      else
        result["Attribute.#{idx}.Name"] = attribute
        result["Attribute.#{idx}.Value"] = ruby_to_sdb(nil) unless skip_values
        idx += 1
      end
    end
  end
  result
end

#put_attributes(domain_name, item_name, attributes, replace = false) ⇒ Object

Add/Replace item attributes.

Params:

domain_name = DomainName
item_name   = ItemName
attributes  = {
  'nameA' => [valueA1,..., valueAN],
  ...
  'nameZ' => [valueZ1,..., valueZN]
}
replace = :replace | any other value to skip replacement

Returns a hash: { :box_usage, :request_id } on success or an exception on error. (Amazon raises no errors if the attribute was not overridden, as when the :replace param is unset).

Example:

sdb = RightAws::SdbInterface.new
sdb.create_domain 'family'

attributes = {}
# create attributes for Jon and Silvia
attributes['Jon']    = %w{ car beer }
attributes['Silvia'] = %w{ beetle rolling_pin kids } 
sdb.put_attributes 'family', 'toys', attributes   #=> ok
# now: Jon=>[car, beer], Silvia=>[beetle, rolling_pin, kids]

# add attributes to Jon
attributes.delete('Silvia')
attributes['Jon'] = %w{ girls pub }
sdb.put_attributes 'family', 'toys', attributes   #=> ok
# now: Jon=>[car, beer, girls, pub], Silvia=>[beetle, rolling_pin, kids]

# replace attributes for Jon and add to a cat (the cat had no attributes before)
attributes['Jon'] = %w{ vacuum_cleaner hammer spade }
attributes['cat'] = %w{ mouse clew Jons_socks }
sdb.put_attributes 'family', 'toys', attributes, :replace #=> ok
# now: Jon=>[vacuum_cleaner, hammer, spade], Silvia=>[beetle, rolling_pin, kids], cat=>[mouse, clew, Jons_socks]

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_PutAttributes.html



310
311
312
313
314
315
316
317
 
# File 'lib/sdb/right_sdb_interface.rb', line 310

def put_attributes(domain_name, item_name, attributes, replace = false)
  params = { 'DomainName' => domain_name,
             'ItemName'   => item_name }.merge(pack_attributes(attributes, replace))
  link = generate_request("PutAttributes", params)
  request_info( link, QSdbSimpleParser.new )
rescue Exception
  on_exception
end

#query(domain_name, query_expression = nil, max_number_of_items = nil, next_token = nil) ⇒ Object

Perform a query on SDB.

Returns a hash:

{ :box_usage  => string,
  :request_id => string,
  :next_token => string,
  :items      => [ItemName1,..., ItemNameN] }

Example:

query = "['cat' = 'clew']"
sdb.query('family', query)     #=> hash of data
sdb.query('family', query, 10) #=> hash of data with max of 10 items

If a block is given, query will iteratively yield results to it as long as the block continues to return true.

# List 10 items per iteration. Don't 
# forget to escape single quotes and backslashes and wrap all the items in single quotes.
query = "['cat'='clew'] union ['dog'='Jon\\'s boot']"
sdb.query('family', query, 10) do |result|
  puts result.inspect
  true
end

# Same query using automatic escaping...to use the auto escape, pass the query and its params as an array:
query = [ "['cat'=?] union ['dog'=?]", "clew", "Jon's boot" ]
sdb.query('family', query)

query = [ "['cat'=?] union ['dog'=?] sort 'cat' desc", "clew", "Jon's boot" ]
sdb.query('family', query)

see: docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/SDB_API_Query.html

http://docs.amazonwebservices.com/AmazonSimpleDB/2007-11-07/DeveloperGuide/index.html?SortingData.html



418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
 
# File 'lib/sdb/right_sdb_interface.rb', line 418

def query(domain_name, query_expression = nil, max_number_of_items = nil, next_token = nil)
  query_expression = query_expression_from_array(query_expression) if query_expression.is_a?(Array)
  @last_query_expression = query_expression
  #
  request_params = { 'DomainName'       => domain_name,
                     'QueryExpression'  => query_expression,
                     'MaxNumberOfItems' => max_number_of_items,
                     'NextToken'        => next_token }
  link   = generate_request("Query", request_params)
  result = request_info( link, QSdbQueryParser.new )
  # return result if no block given
  return result unless block_given?
  # loop if block if given
  begin
    # the block must return true if it wanna continue 
    break unless yield(result) && result[:next_token]
    # make new request
    request_params['NextToken'] = result[:next_token]
    link   = generate_request("Query", request_params)
    result = request_info( link, QSdbQueryParser.new )
  end while true
rescue Exception
  on_exception
end

#query_expression_from_array(params) ⇒ Object

Create query expression from an array. (similar to ActiveRecord::Base#find using :conditions => [‘query’, param1, .., paramN])



170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/sdb/right_sdb_interface.rb', line 170

def query_expression_from_array(params) #:nodoc:
  unless params.blank?
    query = params.shift.to_s
    query.gsub(/(\\)?(\?)/) do
      if $1 # if escaped '\?' is found - replace it by '?' without backslash
        "?"
      else  # well, if no backslash precedes '?' then replace it by next param from the list
        escape(params.shift)
      end
    end
  end
end

#request_info(request, parser) ⇒ Object

Sends request to Amazon and parses the response Raises AwsError if any banana happened



113
114
115
116
117
 
# File 'lib/sdb/right_sdb_interface.rb', line 113

def request_info(request, parser)  #:nodoc:
  thread = @params[:multi_thread] ? Thread.current : Thread.main
  thread[:sdb_connection] ||= Rightscale::HttpConnection.new(:exception => AwsError, :logger => @logger)
  request_info_impl(thread[:sdb_connection], @@bench, request, parser)
end

#ruby_to_sdb(value) ⇒ Object

Convert a Ruby language value to a SDB value by replacing Ruby nil with the user’s chosen string representation of nil. Non-nil values are unaffected by this filter.



157
158
159
 
# File 'lib/sdb/right_sdb_interface.rb', line 157

def ruby_to_sdb(value)
  value.nil? ? @nil_rep : value
end

#sdb_to_ruby(value) ⇒ Object

Convert a SDB value to a Ruby language value by replacing the user’s chosen string representation of nil with Ruby nil. Values are unaffected by this filter unless they match the nil representation exactly.



163
164
165
 
# File 'lib/sdb/right_sdb_interface.rb', line 163

def sdb_to_ruby(value)
  value.eql?(@nil_rep) ? nil : value
end