require 'rubygems' require 'base64' require 'cgi' require 'hmac-sha2' require File.dirname(__FILE__) + '/simpledb/parsers' module Fog module AWS class SimpleDB # Initialize connection to SimpleDB # # ==== Notes # options parameter must include values for :aws_access_key_id and # :aws_secret_access_key in order to create a connection # # ==== Examples # sdb = SimpleDB.new( # :aws_access_key_id => your_aws_access_key_id, # :aws_secret_access_key => your_aws_secret_access_key # ) # # ==== Parameters # options<~Hash>:: config arguments for connection. Defaults to {}. # # ==== Returns # SimpleDB object with connection to aws. def initialize(options={}) @aws_access_key_id = options[:aws_access_key_id] @aws_secret_access_key = options[:aws_secret_access_key] @hmac = HMAC::SHA256.new(@aws_secret_access_key) @host = options[:host] || 'sdb.amazonaws.com' @namespace = options[:namespace] || 'http://sdb.amazonaws.com/doc/2007-11-07/' @nil_string = options[:nil_string]|| 'nil' @port = options[:port] || 443 @scheme = options[:scheme] || 'https' @connection = AWS::Connection.new("#{@scheme}://#{@host}:#{@port}") end # Create a SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # # ==== Returns # Hash:: The :request_id and :box_usage values for the request. def create_domain(domain_name) request({ 'Action' => 'CreateDomain', 'DomainName' => domain_name }, Fog::Parsers::AWS::SimpleDB::BasicParser.new(@nil_string)) end # Delete a SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # # ==== Returns # Hash:: The :request_id and :box_usage values for the request. def delete_domain(domain_name) request({ 'Action' => 'DeleteDomain', 'DomainName' => domain_name }, Fog::Parsers::AWS::SimpleDB::BasicParser.new(@nil_string)) end # List SimpleDB domains # # ==== Parameters # options<~Hash>:: options, defaults to {} # :max_number_of_domains<~Integer>:: number of domains to return # between 1 and 100, defaults to 100 # :next_token<~String>:: Offset token to start listing, defaults to nil # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage # :domains array of domain names. # :next_token offset to start with if there are are more domains to list def list_domains(options = {}) request({ 'Action' => 'ListDomains', 'MaxNumberOfDomains' => options[:max_number_of_domains], 'NextToken' => options[:next_token] }, Fog::Parsers::AWS::SimpleDB::ListDomainsParser.new(@nil_string)) end # List metadata for SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # # ==== Returns # response:: # body<~Hash>:: # :timestamp last update time for metadata. # :item_count number of items in domain # :attribute_value_count number of all name/value pairs in domain # :attribute_name_count number of unique attribute names in domain # :item_name_size_bytes total size of item names in domain, in bytes # :attribute_values_size_bytes total size of attributes, in bytes # :attribute_names_size_bytes total size of unique attribute names, in bytes def domain_metadata(domain_name) request({ 'Action' => 'DomainMetadata', 'DomainName' => domain_name }, Fog::Parsers::AWS::SimpleDB::DomainMetadataParser.new(@nil_string)) end # Put items attributes into a SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # items<~Hash>:: Keys are the items names and may use any UTF-8 # characters valid in xml. Control characters and sequences not allowed # in xml are not valid. Can be up to 1024 bytes long. Values are the # attributes to add to the given item and may use any UTF-8 characters # valid in xml. Control characters and sequences not allowed in xml are # not valid. Each name and value can be up to 1024 bytes long. # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([])) request({ 'Action' => 'BatchPutAttributes', 'DomainName' => domain_name }.merge!(encode_batch_attributes(items, replace_attributes)), Fog::Parsers::AWS::SimpleDB::BasicParser.new(@nil_string)) end # Put item attributes into a SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # item_name<~String>:: Name of the item. May use any UTF-8 characters valid # in xml. Control characters and sequences not allowed in xml are not # valid. Can be up to 1024 bytes long. # attributes<~Hash>:: Name/value pairs to add to the item. Attribute names # and values may use any UTF-8 characters valid in xml. Control characters # and sequences not allowed in xml are not valid. Each name and value can # be up to 1024 bytes long. # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage def put_attributes(domain_name, item_name, attributes, replace_attributes = []) batch_put_attributes(domain_name, { item_name => attributes }, { item_name => replace_attributes }) end # List metadata for SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # item_name<~String>:: Name of the item. May use any UTF-8 characters valid # in xml. Control characters and sequences not allowed in xml are not # valid. Can be up to 1024 bytes long. # attributes<~Hash>:: Name/value pairs to remove from the item. Defaults to # nil, which will delete the entire item. Attribute names and values may # use any UTF-8 characters valid in xml. Control characters and sequences # not allowed in xml are not valid. Each name and value can be up to 1024 # bytes long. # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage def delete_attributes(domain_name, item_name, attributes = nil) request({ 'Action' => 'DeleteAttributes', 'DomainName' => domain_name, 'ItemName' => item_name }.merge!(encode_attributes(attributes)), Fog::Parsers::AWS::SimpleDB::BasicParser.new(@nil_string)) end # List metadata for SimpleDB domain # # ==== Parameters # domain_name<~String>:: Name of domain. Must be between 3 and 255 of the # following characters: a-z, A-Z, 0-9, '_', '-' and '.'. # item_name<~String>:: Name of the item. May use any UTF-8 characters valid # in xml. Control characters and sequences not allowed in xml are not # valid. Can be up to 1024 bytes long. # attributes<~Hash>:: Name/value pairs to return from the item. Defaults to # nil, which will return all attributes. Attribute names and values may use # any UTF-8 characters valid in xml. Control characters and sequences not # allowed in xml are not valid. Each name and value can be up to 1024 # bytes long. # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage # :attributes list of attribute name/values for the item def get_attributes(domain_name, item_name, attributes = nil) request({ 'Action' => 'GetAttributes', 'DomainName' => domain_name, 'ItemName' => item_name, }.merge!(encode_attribute_names(attributes)), Fog::Parsers::AWS::SimpleDB::GetAttributesParser.new(@nil_string)) end # Select item data from SimpleDB # # ==== Parameters # select_expression<~String>:: Expression to query domain with. # next_token<~String>:: Offset token to start list, defaults to nil. # # ==== Returns # response:: # body<~Hash>:: # :request_id and :box_usage # :items list of attribute name/values for the items formatted as # { 'item_name' => { 'attribute_name' => ['attribute_value'] }} # :next_token offset to start with if there are are more domains to list def select(select_expression, next_token = nil) request({ 'Action' => 'Select', 'NextToken' => next_token, 'SelectExpression' => select_expression }, Fog::Parsers::AWS::SimpleDB::SelectParser.new(@nil_string)) end private def encode_batch_attributes(items, replace_attributes = Hash.new([])) encoded_attributes = {} item_index = 0 items.keys.each do |item_key| encoded_attributes["Item.#{item_index}.ItemName"] = item_key.to_s items[item_key].keys.each do |attribute_key| attribute_index = 0 Array(items[item_key][attribute_key]).each do |value| encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Name"] = attribute_key.to_s encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Replace"] = 'true' if replace_attributes[item_key].include?(attribute_key) encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Value"] = sdb_encode(value) attribute_index += 1 end item_index += 1 end end if items encoded_attributes end def encode_attributes(attributes, replace_attributes = []) encoded_attributes = {} i = 0 attributes.keys.each do |key| Array(attributes[key]).each do |value| encoded_attributes["Attribute.#{i}.Name"] = key.to_s encoded_attributes["Attribute.#{i}.Replace"] = 'true' if replace_attributes.include?(key) encoded_attributes["Attribute.#{i}.Value"] = sdb_encode(value) i += 1 end end if attributes encoded_attributes end def encode_attribute_names(attributes) encoded_attribute_names = {} attributes.each_with_index do |attribute, i| encoded_attribute_names["AttributeName.#{i}"] = attribute.to_s end if attributes encoded_attribute_names end def sdb_encode(value) value.nil? ? @nil_string : value.to_s end def request(params, parser) params.delete_if {|key,value| value.nil? } params.merge!({ 'AWSAccessKeyId' => @aws_access_key_id, 'SignatureMethod' => 'HmacSHA256', 'SignatureVersion' => '2', 'Timestamp' => Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"), 'Version' => '2007-11-07' }) query = '' params.keys.sort.each do |key| query << "#{key}=#{CGI.escape(params[key]).gsub(/\+/, '%20')}&" end # FIXME: use 'POST' for larger requests # method = query.length > 2000 ? 'POST' : 'GET' method = 'GET' string_to_sign = "#{method}\n#{@host}\n/\n" << query.chop hmac = @hmac.update(string_to_sign) query << "Signature=#{CGI.escape(Base64.encode64(hmac.digest).chomp!).gsub(/\+/, '%20')}" response = @connection.request({ :host => @host, :method => method, :query => query }) if parser && !response.body.empty? Nokogiri::XML::SAX::Parser.new(parser).parse(response.body.split(/<\?xml.*\?>/)[1]) response.body = parser.response end response end end end end