fog 0.0.3

data/lib/fog/aws/requests/simpledb/get_attributes.rb

@@ -0,0 +1,35 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      # 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<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'Attributes' - list of attribute name/values for the item
+      #     * 'BoxUsage'
+      #     * 'RequestId'
+      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::GetAttributes.new(@nil_string))
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/list_domains.rb

@@ -0,0 +1,30 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      # List SimpleDB domains
+      #
+      # ==== Parameters
+      # * options<~Hash> - options, defaults to {}
+      #   * 'MaxNumberOfDomains'<~Integer> - number of domains to return
+      #     between 1 and 100, defaults to 100
+      #   * 'NextToken'<~String> - Offset token to start listing, defaults to nil
+      #
+      # ==== Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'BoxUsage'
+      #     * 'Domains' - array of domain names.
+      #     * 'NextToken' - offset to start with if there are are more domains to list
+      #     * 'RequestId'
+      def list_domains(options = {})
+        request({
+          'Action' => 'ListDomains',
+          'MaxNumberOfDomains' => options['MaxNumberOfDomains'],
+          'NextToken' => options['NextToken']
+        }, Fog::Parsers::AWS::SimpleDB::ListDomains.new(@nil_string))
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/put_attributes.rb

@@ -0,0 +1,29 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      # 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<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'BoxUsage'
+      #     * 'RequestId'
+      def put_attributes(domain_name, item_name, attributes, replace_attributes = [])
+        batch_put_attributes(domain_name, { item_name => attributes }, { item_name => replace_attributes })
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/simpledb/select.rb

@@ -0,0 +1,29 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      # 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<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'BoxUsage'<~Float>
+      #     * 'RequestId'<~String>
+      #     * 'Items'<~Hash> - list of attribute name/values for the items formatted as 
+      #       { 'item_name' => { 'attribute_name' => ['attribute_value'] }}
+      #     * 'NextToken'<~String> - 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::Select.new(@nil_string))
+      end
+
+    end
+  end
+end

data/lib/fog/aws/s3.rb

@@ -0,0 +1,157 @@
+module Fog
+  module AWS
+    class S3
+
+      if Fog.mocking?
+        def self.reset_data
+          @data = { :buckets => {} }
+        end
+        def self.data
+          @data
+        end
+      end
+
+      def self.reload
+        current_directory = File.dirname(__FILE__)
+        load "#{current_directory}/../collection.rb"
+        load "#{current_directory}/../connection.rb"
+        load "#{current_directory}/../model.rb"
+        load "#{current_directory}/../parser.rb"
+        load "#{current_directory}/../response.rb"
+
+        models_directory = "#{current_directory}/models/s3"
+        load "#{models_directory}/bucket.rb"
+        load "#{models_directory}/buckets.rb"
+        load "#{models_directory}/object.rb"
+        load "#{models_directory}/objects.rb"
+        load "#{models_directory}/owner.rb"
+
+        parsers_directory = "#{current_directory}/parsers/s3"
+        load "#{parsers_directory}/copy_object.rb"
+        load "#{parsers_directory}/get_bucket.rb"
+        load "#{parsers_directory}/get_bucket_location.rb"
+        load "#{parsers_directory}/get_request_payment.rb"
+        load "#{parsers_directory}/get_service.rb"
+
+        requests_directory = "#{current_directory}/requests/s3"
+        load "#{requests_directory}/copy_object.rb"
+        load "#{requests_directory}/delete_bucket.rb"
+        load "#{requests_directory}/delete_object.rb"
+        load "#{requests_directory}/get_bucket.rb"
+        load "#{requests_directory}/get_bucket_location.rb"
+        load "#{requests_directory}/get_object.rb"
+        load "#{requests_directory}/get_request_payment.rb"
+        load "#{requests_directory}/get_service.rb"
+        load "#{requests_directory}/head_object.rb"
+        load "#{requests_directory}/put_bucket.rb"
+        load "#{requests_directory}/put_object.rb"
+        load "#{requests_directory}/put_request_payment.rb"
+
+        if Fog.mocking?
+          reset_data
+        end
+      end
+
+      # Initialize connection to S3
+      #
+      # ==== Notes
+      # options parameter must include values for :aws_access_key_id and 
+      # :aws_secret_access_key in order to create a connection
+      #
+      # ==== Examples
+      #   sdb = S3.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
+      # * S3 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::SHA1.new(@aws_secret_access_key)
+        @host       = options[:host]      || 's3.amazonaws.com'
+        @port       = options[:port]      || 443
+        @scheme     = options[:scheme]    || 'https'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
+      end
+
+      private
+
+      def parse_file(file)
+        metadata = {
+          :body => nil,
+          :headers => {}
+        }
+
+        filename = File.basename(file.path)
+        unless (mime_types = MIME::Types.of(filename)).empty?
+          metadata[:headers]['Content-Type'] = mime_types.first.content_type
+        end
+
+        metadata[:body] = file.read
+        metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
+        metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
+        metadata
+      end
+
+      def request(params)
+        params[:headers]['Date'] = Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+        string_to_sign =
+<<-DATA
+#{params[:method]}
+#{params[:headers]['Content-MD5']}
+#{params[:headers]['Content-Type']}
+#{params[:headers]['Date']}
+DATA
+
+        amz_headers, canonical_amz_headers = {}, ''
+        for key, value in params[:headers]
+          if key[0..5] == 'x-amz-'
+            amz_headers[key] = value
+          end
+        end
+        amz_headers = amz_headers.sort {|x, y| x[0] <=> y[0]}
+        for pair in amz_headers
+          canonical_amz_headers << "#{pair[0]}:#{pair[1]}\n"
+        end
+        string_to_sign << "#{canonical_amz_headers}"
+
+        canonical_resource  = "/"
+        subdomain = params[:host].split(".#{@host}").first
+        unless subdomain == @host
+          canonical_resource << "#{subdomain}/"
+        end
+        canonical_resource << "#{params[:path]}"
+        if ['acl', 'location', 'logging', 'requestPayment', 'torrent'].include?(params[:query])
+          canonical_resource << "?#{params[:query]}"
+        end
+        string_to_sign << "#{canonical_resource}"
+
+        hmac = @hmac.update(string_to_sign)
+        signature = Base64.encode64(hmac.digest).chomp!
+        params[:headers]['Authorization'] = "AWS #{@aws_access_key_id}:#{signature}"
+
+        response = @connection.request({
+          :body     => params[:body],
+          :expects  => params[:expects],
+          :headers  => params[:headers],
+          :host     => params[:host],
+          :method   => params[:method],
+          :parser   => params[:parser],
+          :path     => params[:path],
+          :query    => params[:query]
+        })
+
+        response
+      end
+
+    end
+  end
+end
+
+Fog::AWS::S3.reload

data/lib/fog/aws/simpledb.rb

@@ -0,0 +1,157 @@
+module Fog
+  module AWS
+    class SimpleDB
+
+      def self.reload
+        current_directory = File.dirname(__FILE__)
+        load "#{current_directory}/../connection.rb"
+        load "#{current_directory}/../parser.rb"
+        load "#{current_directory}/../response.rb"
+
+        parsers_directory = "#{current_directory}/parsers/simpledb"
+        load "#{parsers_directory}/basic.rb"
+        load "#{parsers_directory}/domain_metadata.rb"
+        load "#{parsers_directory}/get_attributes.rb"
+        load "#{parsers_directory}/list_domains.rb"
+        load "#{parsers_directory}/select.rb"
+
+        requests_directory = "#{current_directory}/requests/simpledb"
+        load "#{requests_directory}/batch_put_attributes.rb"
+        load "#{requests_directory}/create_domain.rb"
+        load "#{requests_directory}/delete_attributes.rb"
+        load "#{requests_directory}/delete_domain.rb"
+        load "#{requests_directory}/domain_metadata.rb"
+        load "#{requests_directory}/get_attributes.rb"
+        load "#{requests_directory}/list_domains.rb"
+        load "#{requests_directory}/put_attributes.rb"
+        load "#{requests_directory}/select.rb"
+      end
+
+      # 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'
+        @nil_string = options[:nil_string]|| 'nil'
+        @port       = options[:port]      || 443
+        @scheme     = options[:scheme]    || 'https'
+        @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}")
+      end
+
+      private
+
+      def encode_attributes(attributes, replace_attributes = [])
+        encoded_attributes = {}
+        if attributes
+          index = 0
+          for key in attributes.keys
+            for value in Array(attributes[key])
+              encoded_attributes["Attribute.#{index}.Name"] = key.to_s
+              if replace_attributes.include?(key)
+                encoded_attributes["Attribute.#{index}.Replace"] = 'true'
+              end
+              encoded_attributes["Attribute.#{index}.Value"] = sdb_encode(value)
+              index += 1
+            end
+          end
+        end
+        encoded_attributes
+      end
+
+      def encode_attribute_names(attributes)
+        encoded_attribute_names = {}
+        if attributes
+          index = 0
+          for attribute in attributes
+            encoded_attribute_names["AttributeName.#{index}"] = attribute.to_s
+            index += 1
+          end
+        end
+        encoded_attribute_names
+      end
+
+      def encode_batch_attributes(items, replace_attributes = Hash.new([]))
+        encoded_attributes = {}
+        if items
+          item_index = 0
+          for item_key in items.keys
+            encoded_attributes["Item.#{item_index}.ItemName"] = item_key.to_s
+            for attribute_key in items[item_key].keys
+              attribute_index = 0
+              for value in Array(items[item_key][attribute_key])
+                encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Name"] = attribute_key.to_s
+                if replace_attributes[item_key].include?(attribute_key)
+                  encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Replace"] = 'true'
+                end
+                encoded_attributes["Item.#{item_index}.Attribute.#{attribute_index}.Value"] = sdb_encode(value)
+                attribute_index += 1
+              end
+              item_index += 1
+            end
+          end
+        end
+        encoded_attributes
+      end
+
+      def request(params, parser)
+        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'
+        })
+
+        body = ''
+        for key in params.keys.sort
+          unless (value = params[key]).nil?
+            body << "#{key}=#{CGI.escape(value.to_s).gsub(/\+/, '%20')}&"
+          end
+        end
+
+        string_to_sign = "POST\n#{@host}\n/\n" << body.chop
+        hmac = @hmac.update(string_to_sign)
+        body << "Signature=#{CGI.escape(Base64.encode64(hmac.digest).chomp!).gsub(/\+/, '%20')}"
+
+        response = @connection.request({
+          :body => body,
+          :expects => 200,
+          :headers => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+          :host => @host,
+          :method => 'POST',
+          :parser => parser
+        })
+
+        response
+      end
+
+      def sdb_encode(value)
+        if value.nil?
+          @nil_string
+        else
+          value.to_s
+        end
+      end
+
+    end
+  end
+end
+
+Fog::AWS::SimpleDB.reload

data/lib/fog/collection.rb

@@ -0,0 +1,77 @@
+module Fog
+  class Collection < Hash
+
+    def self.attribute(name, other_names = [])
+      class_eval <<-EOS, __FILE__, __LINE__
+        attr_accessor :#{name}
+      EOS
+      attributes << name
+      for other_name in [*other_names]
+        aliases[other_name] = name
+      end
+    end
+
+    def self.aliases
+      @aliases ||= {}
+    end
+
+    def self.attributes
+      @attributes ||= []
+    end
+
+    def initialize(attributes = {})
+      merge_attributes(attributes)
+    end
+
+    def inspect
+      data = "#<#{self.class.name}"
+      for attribute in self.class.attributes
+        data << " #{attribute}=#{send(attribute).inspect}"
+      end
+      data << " ["
+      for key, value in self
+        data << "#{value.inspect},"
+      end
+      data.chomp!
+      data << "]>"
+    end
+
+    def attributes
+      attributes = {}
+      for attribute in self.class.attributes
+        attributes[attribute] = send(:"#{attribute}")
+      end
+      attributes
+    end
+
+    def merge_attributes(new_attributes = {})
+      for key, value in new_attributes
+        if aliased_key = self.class.aliases[key]
+          send(:"#{aliased_key}=", value)
+        else
+          send(:"#{key}=", value)
+        end
+      end
+      self
+    end
+
+    private
+
+    def connection=(new_connection)
+      @connection = new_connection
+    end
+
+    def connection
+      @connection
+    end
+
+    def remap_attributes(attributes, mapping)
+      for key, value in mapping
+        if attributes.key?(key)
+          attributes[value] = attributes.delete(key)
+        end
+      end
+    end
+
+  end
+end