Class Rudy::AWS::SDB

  1. lib/rudy/aws/sdb/error.rb
  2. lib/rudy/aws/sdb.rb
  3. show all
Parent: Object

Public class methods

generate_select (domain, fields={})

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

[show source] 
    # File lib/rudy/aws/sdb.rb, line 67
67:       def self.generate_select(domain, fields={})
68:         query = []
69:         fields.each_pair do |n,v| 
70:           query << "#{Rudy::AWS.escape n}='#{Rudy::AWS.escape v}'"
71:         end
72:         str = "select * from #{domain} " 
73:         str << " where "<< query.join(' and ') unless query.empty?
74:         str
75:       end
new (access_key=nil, secret_key=nil, region=nil, debug=nil)
[show source] 
    # File lib/rudy/aws/sdb.rb, line 19
19:       def initialize(access_key=nil, secret_key=nil, region=nil, debug=nil)
20:         raise NoAccessKey if access_key.nil? || access_key.empty?
21:         raise NoSecretKey if secret_key.nil? || secret_key.empty?
22:           
23:         url ||= 'http://sdb.amazonaws.com'
24:         # There is a bug with passing :server to EC2::Base.new so 
25:         # we'll use the environment variable for now. 
26:         #if region && Rudy::AWS.valid_region?(region)
27:         #  "#{region}.sdb.amazonaws.com"
28:         #end
29:         
30:         @access_key_id = access_key || ENV['AWS_ACCESS_KEY']
31:         @secret_access_key = secret_key || ENV['AWS_SECRET_KEY']
32:         @base_url = url
33:         @debug = debug || StringIO.new
34:       end

Public instance methods

create_domain (domain)
[show source] 
    # File lib/rudy/aws/sdb.rb, line 51
51:       def create_domain(domain)
52:         call(:post, { 'Action' => 'CreateDomain', 'DomainName'=> domain.to_s })
53:         true
54:       end
delete_attributes (domain, item)
[show source] 
     # File lib/rudy/aws/sdb.rb, line 159
159:       def delete_attributes(domain, item)
160:         call(
161:           :delete,
162:           {
163:             'Action' => 'DeleteAttributes',
164:             'DomainName' => domain.to_s,
165:             'ItemName' => item.to_s
166:           }
167:         )
168:         true
169:       end
destroy (domain, item)

Alias for delete_attributes

destroy_domain (domain)
[show source] 
    # File lib/rudy/aws/sdb.rb, line 56
56:       def destroy_domain(domain)
57:         call(
58:           :delete,
59:           { 'Action' => 'DeleteDomain', 'DomainName' => domain.to_s }
60:         )
61:         true
62:       end
get (domain, item)

Alias for get_attributes

get_attributes (domain, item)
[show source] 
     # File lib/rudy/aws/sdb.rb, line 136
136:       def get_attributes(domain, item)
137:         doc = call(
138:           :get,
139:           {
140:             'Action' => 'GetAttributes',
141:             'DomainName' => domain.to_s,
142:             'ItemName' => item.to_s
143:           }
144:         )
145:         attributes = {}
146:         if doc
147:           REXML::XPath.each(doc, "//Attribute") do |attr|
148:             key = REXML::XPath.first(attr, './Name/text()').to_s
149:             value = REXML::XPath.first(attr, './Value/text()').to_s
150:             ( attributes[key] ||= [] ) << value
151:           end
152:         end
153:         attributes = nil if attributes.empty?
154:         attributes
155:       end
list_domains (max = nil, token = nil)
[show source] 
    # File lib/rudy/aws/sdb.rb, line 36
36:       def list_domains(max = nil, token = nil)
37:         params = { 'Action' => 'ListDomains' }
38:         params['NextToken'] =
39:           token unless token.nil? || token.empty?
40:         params['MaxNumberOfDomains'] =
41:           max.to_s unless max.nil? || max.to_i == 0
42:         doc = call(:get, params)
43:         results = []
44:         REXML::XPath.each(doc, '//DomainName/text()') do |domain|
45:           results << domain.to_s
46:         end
47:         #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
48:         results
49:       end
put (domain, item, attributes, replace = true)

Alias for put_attributes

put_attributes (domain, item, attributes, replace = true)
[show source] 
     # File lib/rudy/aws/sdb.rb, line 112
112:       def put_attributes(domain, item, attributes, replace = true)
113:         replace = true if replace == :replace
114:         params = {
115:           'Action' => 'PutAttributes',
116:           'DomainName' => domain.to_s,
117:           'ItemName' => item.to_s
118:         }
119:         count = 0
120:         
121:         attributes.each do | key, values |
122:           ([]<<values).flatten.each do |value|
123:             params["Attribute.#{count}.Name"] = key.to_s
124:             params["Attribute.#{count}.Value"] = value.to_s
125:             params["Attribute.#{count}.Replace"] = replace
126:             count += 1
127:           end
128:         end
129:         
130:         call(:put, params)
131:         
132:         true
133:       end
select (select, token = nil)
[show source] 
     # File lib/rudy/aws/sdb.rb, line 78
 78:       def select(select, token = nil)
 79:         params = {
 80:           'Action' => 'Select',
 81:           'SelectExpression' => select,
 82:         }
 83:         params['NextToken'] =
 84:           token unless token.nil? || token.empty?
 85:           
 86:         doc = call(:get, params)
 87:         results = []
 88:         if doc
 89:           REXML::XPath.each(doc, "//Item") do |item|
 90:             name = REXML::XPath.first(item, './Name/text()').to_s
 91: 
 92:             attributes = {'Name' => name}
 93:             REXML::XPath.each(item, "./Attribute") do |attr|
 94:               key = REXML::XPath.first(attr, './Name/text()').to_s
 95:               value = REXML::XPath.first(attr, './Value/text()').to_s
 96:               ( attributes[key] ||= [] ) << value
 97:             end
 98:             results << attributes
 99:           end
100:           #return results, REXML::XPath.first(doc, '//NextToken/text()').to_s
101:         end
102:         
103:         hash_results = {}
104:         results.each do |item|
105:           hash_results[item.delete('Name')] = item
106:         end
107:         
108:         hash_results.empty? ? nil : hash_results
109:       end

Protected instance methods

call (method, params)
[show source] 
     # File lib/rudy/aws/sdb.rb, line 204
204:       def call(method, params)
205:         params.merge!( {
206:             'Version' => '2007-11-07',
207:             'SignatureVersion' => '1',
208:             'AWSAccessKeyId' => @access_key_id,
209:             'Timestamp' => Time.now.gmtime.iso8601
210:           }
211:         )
212:         data = ''
213:         query = []
214:         
215:         params.keys.sort_by { |k| k.upcase }.each do |key|
216:           data << "#{key}#{params[key].to_s}"
217:           query << "#{key}=#{CGI::escape(params[key].to_s)}"
218:         end
219:         
220:         digest = OpenSSL::Digest::Digest.new('sha1')
221:         hmac = OpenSSL::HMAC.digest(digest, @secret_access_key, data)
222:         signature = Base64.encode64(hmac).strip
223:         query << "Signature=#{CGI::escape(signature)}"
224:         query = query.join('&')
225:         url = "#{@base_url}?#{query}"
226:         uri = URI.parse(url)
227:         
228:         #Rudy::Huxtable.ld url if Rudy.debug?
229:         
230:         response = execute_request(nil) {
231:           Net::HTTP.new(uri.host, uri.port).send_request(method, uri.request_uri)
232:         }
233:         
234:         if !response.nil?
235:         
236:           @debug.puts("#{response.code}\n#{response.body}") if @debug
237:           raise(ConnectionError.new(response)) unless (200..400).include?(
238:             response.code.to_i
239:           )
240: 
241: 
242:           doc = REXML::Document.new(response.body)
243:           error = doc.get_elements('*/Errors/Error')[0]
244:           raise(
245:             Module.class_eval(
246:               "Rudy::AWS::SDB::#{error.get_elements('Code')[0].text}Error"
247:             ).new(
248:               error.get_elements('Message')[0].text,
249:               doc.get_elements('*/RequestID')[0].text
250:             )
251:           ) unless error.nil?
252:         else
253:           doc = nil
254:         end
255:         doc
256:       end
execute_request (default=nil, timeout=nil, &request)

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.

[show source] 
     # File lib/rudy/aws/sdb.rb, line 183
183:       def execute_request(default=nil, timeout=nil, &request)
184:         timeout ||= 30
185:         raise "No block provided" unless request
186:         response = nil
187:         begin
188:           Timeout::timeout(timeout) do
189:             response = request.call
190:           end
191: 
192:         rescue Timeout::Error => ex
193:           Rudy::Huxtable.le "Timeout (#{timeout}): #{ex.message}!"
194:         rescue SocketError => ex
195:           #Rudy::Huxtable.le ex.message
196:           #Rudy::Huxtable.le ex.backtrace
197:           raise SocketError, "Check your Internets!" unless Rudy::Huxtable.global.offline
198:         ensure
199:           response ||= default
200:         end
201:         response
202:       end