tecnh-fog 0.2.23.vpc

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

@@ -0,0 +1,64 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        # 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<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          request({
+            'Action'      => 'BatchPutAttributes',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          }.merge!(encode_batch_attributes(items, replace_attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def batch_put_attributes(domain_name, items, replace_attributes = Hash.new([]))
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            for item_name, attributes in items do
+              for key, value in attributes do
+                @data[:domains][domain_name][item_name] ||= {}
+                if replace_attributes[item_name] && replace_attributes[item_name].include?(key)
+                  @data[:domains][domain_name][item_name][key.to_s] = []
+                else
+                  @data[:domains][domain_name][item_name][key.to_s] ||= []
+                end
+                @data[:domains][domain_name][item_name][key.to_s] << value.to_s
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        # 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
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def create_domain(domain_name)
+          request(
+            'Action'      => 'CreateDomain',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_domain(domain_name)
+          response = Excon::Response.new
+          @data[:domains][domain_name] = {}
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        # 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<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          request({
+            'Action'      => 'DeleteAttributes',
+            'DomainName'  => domain_name,
+            'ItemName'    => item_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          }.merge!(encode_attributes(attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def delete_attributes(domain_name, item_name, attributes = nil)
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            if attributes
+              for key, value in attributes
+                if @data[:domains][domain_name][key]
+                  @data[:domains][domain_name][key].delete('value')
+                end
+              end
+            else
+              @data[:domains].delete(domain_name)
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        # 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
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def delete_domain(domain_name)
+          request(
+            'Action'      => 'DeleteDomain',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_domain(domain_name)
+          response = Excon::Response.new
+          if @data[:domains].delete(domain_name)
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/domain_metadata'
+
+        # 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<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'AttributeNameCount' - number of unique attribute names in domain
+        #     * 'AttributeNamesSizeBytes' - total size of unique attribute names, in bytes
+        #     * 'AttributeValueCount' - number of all name/value pairs in domain
+        #     * 'AttributeValuesSizeBytes' - total size of attributes, in bytes
+        #     * 'BoxUsage'
+        #     * 'ItemCount' - number of items in domain
+        #     * 'ItemNameSizeBytes' - total size of item names in domain, in bytes
+        #     * 'RequestId'
+        #     * 'Timestamp' - last update time for metadata.
+        def domain_metadata(domain_name)
+          request(
+            'Action'      => 'DomainMetadata',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::DomainMetadata.new(@nil_string)
+          )
+        end
+
+      end
+
+      class Mock
+
+        def domain_metadata(domain_name)
+          response = Excon::Response.new
+          if domain = @data[:domains][domain_name]
+            response.status = 200
+          
+            attribute_names = []
+            attribute_values = []
+            for item in domain.values
+              for key, values in item
+                attribute_names << key
+                for value in values
+                  attribute_values << value
+                end
+              end
+            end
+          
+            response.body = {
+              'AttributeNameCount'        => attribute_names.length,
+              'AttributeNamesSizeBytes'   => attribute_names.join('').length,
+              'AttributeValueCount'       => attribute_values.length,
+              'AttributeValuesSizeBytes'  => attribute_values.join('').length,
+              'BoxUsage'                  => Fog::AWS::Mock.box_usage,
+              'ItemCount'                 => domain.keys.length,
+              'ItemNamesSizeBytes'        => domain.keys.join('').length,
+              'RequestId'                 => Fog::AWS::Mock.request_id,
+              'Timestamp'                 => Time.now
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/get_attributes'
+
+        # 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<~Array> - Attributes to return from the item.  Defaults to
+        #   {}, 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<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Attributes' - list of attribute name/values for the item
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def get_attributes(domain_name, item_name, attributes = {})
+          
+          request({
+            'Action'      => 'GetAttributes',
+            'DomainName'  => domain_name,
+            'ItemName'    => item_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::GetAttributes.new(@nil_string)
+          }.merge!(encode_attribute_names(attributes)))
+        end
+
+      end
+
+      class Mock
+
+        def get_attributes(domain_name, item_name, attributes = nil)
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            object = {}
+            if attributes
+              for attribute in attributes
+                if @data[:domains][domain_name][item_name] && @data[:domains][domain_name][item_name]
+                  object[attribute] = @data[:domains][domain_name][item_name][attribute]
+                end
+              end
+            elsif @data[:domains][domain_name][item_name]
+              object = @data[:domains][domain_name][item_name]
+            end
+            response.status = 200
+            response.body = {
+              'Attributes'  => object,
+              'BoxUsage'    => Fog::AWS::Mock.box_usage,
+              'RequestId'   => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        require 'fog/aws/parsers/simpledb/list_domains'
+
+        # 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<~Excon::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',
+            :parser  => Fog::Parsers::AWS::SimpleDB::ListDomains.new(@nil_string)
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def list_domains(options = {})
+          response = Excon::Response.new
+          keys = @data[:domains].keys
+          max = options['MaxNumberOfDomains'] || keys.size
+          offset = options['NextToken'] || 0
+          domains = []
+          for key, value in @data[:domains].keys[offset...max]
+            domains << key
+          end
+          response.status = 200
+          response.body = {
+            'BoxUsage'  => Fog::AWS::Mock.box_usage,
+            'Domains'   => domains,
+            'RequestId' => Fog::AWS::Mock.request_id
+          }
+          if max < keys.size
+            response.body['NextToken'] = max + 1
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Fog
+  module AWS
+    module SimpleDB
+      class Real
+
+        # 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.
+        # * options<~Hash> - Accepts the following keys.
+        #   :replace => [Array of keys to replace]
+        #   :expect => {name/value pairs for performing conditional put}
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'BoxUsage'
+        #     * 'RequestId'
+        def put_attributes(domain_name, item_name, attributes, options = {})
+          options[:expect] = {} unless options[:expect]
+          options[:replace] = [] unless options[:replace]
+          request({
+            'Action'      => 'PutAttributes',
+            'DomainName'  => domain_name,
+            :parser       => Fog::Parsers::AWS::SimpleDB::Basic.new(@nil_string),
+            'ItemName' => item_name
+          }.merge!(encode_attributes(attributes, options[:replace], options[:expect])))
+        end
+
+      end
+
+      class Mock
+
+        def put_attributes(domain_name, item_name, attributes, options = {})
+          options[:expect] = {} unless options[:expect]
+          options[:replace] = [] unless options[:replace]
+          response = Excon::Response.new
+          if @data[:domains][domain_name]
+            options[:expect].each do |ck, cv|
+              if @data[:domains][domain_name][item_name][ck] != [cv]
+                response.status = 409
+                raise(Excon::Errors.status_error({:expects => 200}, response))
+              end
+            end
+            attributes.each do |key, value|
+              @data[:domains][domain_name][item_name] ||= {}
+              @data[:domains][domain_name][item_name][key.to_s] = [] unless @data[:domains][domain_name][item_name][key.to_s]
+              if options[:replace].include?(key.to_s)
+                @data[:domains][domain_name][item_name][key.to_s] = [value.to_s]
+              else
+                @data[:domains][domain_name][item_name][key.to_s] += [value.to_s]
+              end
+            end
+            response.status = 200
+            response.body = {
+              'BoxUsage'  => Fog::AWS::Mock.box_usage,
+              'RequestId' => Fog::AWS::Mock.request_id
+            }
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 200}, response))
+
+          end
+          response
+        end
+
+      end
+    end
+  end
+end