fog 1.26.0 → 1.27.0

data/lib/fog/aws/requests/dynamodb/put_item.rb

@@ -1,39 +0,0 @@
-module Fog
-  module AWS
-    class DynamoDB
-      class Real
-        # Update DynamoDB item
-        #
-        # ==== Parameters
-        # * 'table_name'<~String> - name of table for item
-        # * 'item'<~Hash>: data to update, must include primary key
-        #   * 'AttributeName'<~String> - Attribute to update
-        #     * 'Value'<~Hash> - formated as {type => value}
-        #     * 'Action'<~String> - action to take if expects matches, in %w{ADD DELETE PUT}, defaults to PUT
-        # * 'options'<~Hash>:
-        #   * 'Expected'<~Hash>: data to check against
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'Value'<~Hash> - a value to check for the value of
-        #     or
-        #     * 'Exists'<~Boolean> - set as false to only allow update if attribute doesn't exist
-        #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     varies based on ReturnValues param, see: http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_UpdateItem.html
-        def put_item(table_name, item, options = {})
-          body = {
-            'Item'      => item,
-            'TableName' => table_name
-          }.merge(options)
-
-          request(
-            :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20120810.PutItem'}
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/dynamodb/query.rb

@@ -1,42 +0,0 @@
-module Fog
-  module AWS
-    class DynamoDB
-      class Real
-        # Query DynamoDB items
-        #
-        # ==== Parameters
-        # * 'table_name'<~String> - name of table to query
-        # * 'hash_key'<~Hash> - hash key to query
-        # * options<~Hash>:
-        #   * 'AttributesToGet'<~Array> - Array of attributes to get for each item, defaults to all
-        #   * 'ConsistentRead'<~Boolean> - Whether to wait for consistency, defaults to false
-        #   * 'Count'<~Boolean> - If true, returns only a count of such items rather than items themselves, defaults to false
-        #   * 'Limit'<~Integer> - limit of total items to return
-        #   * 'RangeKeyCondition'<~Hash>: value to compare against range key
-        #     * 'AttributeValueList'<~Hash>: one or more values to compare against
-        #     * 'ComparisonOperator'<~String>: comparison operator to use with attribute value list, in %w{BETWEEN BEGINS_WITH EQ LE LT GE GT}
-        #   * 'ScanIndexForward'<~Boolean>: Whether to scan from start or end of index, defaults to start
-        #   * 'ExclusiveStartKey'<~Hash>: Key to start listing from, can be taken from LastEvaluatedKey in response
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ConsumedCapacityUnits'<~Integer> - number of capacity units used for query
-        #     * 'Count'<~Integer> - number of items in response
-        #     * 'Items'<~Array> - array of items returned
-        #     * 'LastEvaluatedKey'<~Hash> - last key scanned, can be passed to ExclusiveStartKey for pagination
-        def query(table_name, hash_key, options = {})
-          body = {
-            'TableName'     => table_name,
-            'HashKeyValue'  => hash_key
-          }.merge(options)
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.Query'}
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/dynamodb/scan.rb

@@ -1,43 +0,0 @@
-module Fog
-  module AWS
-    class DynamoDB
-      class Real
-        # Scan DynamoDB items
-        #
-        # ==== Parameters
-        # * 'table_name'<~String> - name of table to query
-        # * options<~Hash>:
-        #   * 'AttributesToGet'<~Array> - Array of attributes to get for each item, defaults to all
-        #   * 'ConsistentRead'<~Boolean> - Whether to wait for consistency, defaults to false
-        #   * 'Count'<~Boolean> - If true, returns only a count of such items rather than items themselves, defaults to false
-        #   * 'Limit'<~Integer> - limit of total items to return
-        #   * 'ScanFilter'<~Hash>: value to compare against
-        #     * attribute_name<~Hash>:
-        #       * 'AttributeValueList'<~Hash>: one or more values to compare against
-        #       * 'ComparisonOperator'<~String>: comparison operator to use with attribute value list, in %w{BETWEEN BEGINS_WITH EQ LE LT GE GT}
-        #   * 'ScanIndexForward'<~Boolean>: Whether to scan from start or end of index, defaults to start
-        #   * 'ExclusiveStartKey'<~Hash>: Key to start listing from, can be taken from LastEvaluatedKey in response
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ConsumedCapacityUnits'<~Integer> - number of capacity units used for scan
-        #     * 'Count'<~Integer> - number of items in response
-        #     * 'Items'<~Array> - array of items returned
-        #     * 'LastEvaluatedKey'<~Hash> - last key scanned, can be passed to ExclusiveStartKey for pagination
-        #     * 'ScannedCount'<~Integer> - number of items scanned before applying filters
-        def scan(table_name, options = {})
-          body = {
-            'TableName'     => table_name
-          }.merge(options)
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.Scan'},
-            :idempotent => true
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/dynamodb/update_item.rb

@@ -1,47 +0,0 @@
-module Fog
-  module AWS
-    class DynamoDB
-      class Real
-        # Update DynamoDB item
-        #
-        # ==== Parameters
-        # * 'table_name'<~String> - name of table for item
-        # * 'key'<~Hash>:
-        #   * 'HashKeyElement'<~Hash>: info for primary key
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'AttributeType'<~String> - type of attribute
-        #   * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'AttributeType'<~String> - type of attribute
-        # * 'attribute_updates'<~Hash>:
-        #   * 'AttributeName'<~String> - Attribute to update
-        #     * 'Value'<~Hash> - formated as {type => value}
-        #     * 'Action'<~String> - action to take if expects matches, in %w{ADD DELETE PUT}, defaults to PUT
-        # * 'options'<~Hash>:
-        #   * 'Expected'<~Hash>: data to check against
-        #     * 'AttributeName'<~String> - name of attribute
-        #     * 'Value'<~Hash> - a value to check for the value of
-        #     or
-        #     * 'Exists'<~Boolean> - set as false to only allow update if attribute doesn't exist
-        #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     varies based on ReturnValues param, see: http://docs.amazonwebservices.com/amazondynamodb/latest/developerguide/API_UpdateItem.html
-        def update_item(table_name, key, attribute_updates, options = {})
-          body = {
-            'AttributeUpdates'  => attribute_updates,
-            'Key'               => key,
-            'TableName'         => table_name
-          }.merge(options)
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :headers  => {'x-amz-target' => 'DynamoDB_20111205.UpdateItem'}
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/dynamodb/update_table.rb

@@ -1,44 +0,0 @@
-module Fog
-  module AWS
-    class DynamoDB
-      class Real
-        # Update DynamoDB table throughput
-        #
-        # ==== Parameters
-        # * 'table_name'<~String> - name of table to describe
-        # * 'provisioned_throughput'<~Hash>:
-        #   * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
-        #   * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'Table'<~Hash>
-        #       * 'KeySchema'<~Hash> - schema for table
-        #         * 'HashKeyElement'<~Hash>: info for primary key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
-        #         * 'RangeKeyElement'<~Hash>: optional, info for range key
-        #           * 'AttributeName'<~String> - name of attribute
-        #           * 'AttributeType'<~String> - type of attribute, in %w{N NS S SS} for number, number set, string, string set
-        #       * 'ProvisionedThroughput'<~Hash>:
-        #         * 'ReadCapacityUnits'<~Integer> - read capacity for table, in 5..10000
-        #         * 'WriteCapacityUnits'<~Integer> - write capacity for table, in 5..10000
-        #       * 'TableName'<~String> - name of table
-        #       * 'TableStatus'<~String> - status of table
-        def update_table(table_name, provisioned_throughput)
-          body = {
-            'ProvisionedThroughput' => provisioned_throughput,
-            'TableName'             => table_name
-          }
-
-          request(
-            :body       => Fog::JSON.encode(body),
-            :headers    => {'x-amz-target' => 'DynamoDB_20111205.UpdateTable'},
-            :idempotent => true
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elasticache/authorize_cache_security_group_ingress.rb

@@ -1,57 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/single_security_group'
-
-        # Authorize ingress to a CacheSecurityGroup using EC2 Security Groups
-        #
-        # === Parameters
-        # * name <~String> - The name of the cache security group
-        # * ec2_name <~String> - The name of the EC2 security group to authorize
-        # * ec2_owner_id <~String> - The AWS Account Number of the EC2 security group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def authorize_cache_security_group_ingress(name, ec2_name, ec2_owner_id)
-          request({
-            'Action' => 'AuthorizeCacheSecurityGroupIngress',
-            'CacheSecurityGroupName' => name,
-            'EC2SecurityGroupName' => ec2_name,
-            'EC2SecurityGroupOwnerId' => ec2_owner_id,
-            :parser => Fog::Parsers::AWS::Elasticache::SingleSecurityGroup.new
-          })
-        end
-      end
-
-      class Mock
-        def authorize_cache_security_group_ingress(name, ec2_name, ec2_owner_id)
-          opts = {
-            'EC2SecurityGroupName' => ec2_name,
-            'EC2SecurityGroupOwnerId' => ec2_owner_id
-          }
-
-          if sec_group = self.data[:security_groups][name]
-
-            if sec_group['EC2SecurityGroups'].find{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
-              raise Fog::AWS::Elasticache::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
-            end
-            sec_group['EC2SecurityGroups'] << opts.merge({'Status' => 'authorizing'})
-
-            Excon::Response.new(
-                {
-                    :status => 200,
-                    :body => {
-                        'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
-                        'CacheSecurityGroup' => sec_group
-                    }
-                }
-            )
-          else
-            raise Fog::AWS::Elasticache::NotFound.new("CacheSecurityGroupNotFound => #{name} not found")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elasticache/create_cache_cluster.rb

@@ -1,94 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/single_cache_cluster'
-        # creates a cache cluster
-        #
-        # === Required Parameters
-        # * id <~String> - A unique cluster ID - 20 characters max.
-        # === Optional Parameters
-        # * options <~Hash> - All optional parameters should be set in this Hash:
-        #   * :node_type <~String> - The size (flavor) of the cache Nodes
-        #   * :security_group_names <~Array> - Array of Elasticache::SecurityGroup names
-        #   * :vpc_security_groups <~Array> - Array
-        #   * :num_nodes <~Integer> - The number of nodes in the Cluster
-        #   * :auto_minor_version_upgrade <~TrueFalseClass>
-        #   * :parameter_group_name <~String> - Name of the Cluster's ParameterGroup
-        #   * :engine <~String> - The Cluster's caching software (memcached)
-        #   * :engine_version <~String> - The Cluster's caching software version
-        #   * :notification_topic_arn <~String> - Amazon SNS Resource Name
-        #   * :port <~Integer> - The memcached port number
-        #   * :preferred_availablility_zone <~String>
-        #   * :preferred_maintenance_window <~String>
-        #   * :cache_subnet_group_name <~String>
-        #   * :s3_snapshot_location <~String> - Amazon resource location for snapshot
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def create_cache_cluster(id, options = {})
-          req_options = {
-            'Action'          => 'CreateCacheCluster',
-            'CacheClusterId'  => id.strip,
-            'CacheNodeType'   => options[:node_type]  || 'cache.m1.large',
-            'Engine'          => options[:engine]     || 'memcached',
-            'NumCacheNodes'   => options[:num_nodes]  || 1,
-            'AutoMinorVersionUpgrade'     => options[:auto_minor_version_upgrade],
-            'CacheParameterGroupName'     => options[:parameter_group_name],
-            'CacheSubnetGroupName'        => options[:cache_subnet_group_name],
-            'EngineVersion'               => options[:engine_version],
-            'NotificationTopicArn'        => options[:notification_topic_arn],
-            'Port'                        => options[:port],
-            'PreferredAvailabilityZone'   => options[:preferred_availablility_zone],
-            'PreferredMaintenanceWindow'  => options[:preferred_maintenance_window],
-            :parser => Fog::Parsers::AWS::Elasticache::SingleCacheCluster.new
-          }
-
-          if s3_snapshot_location = options.delete(:s3_snapshot_location)
-            req_options.merge!(Fog::AWS.indexed_param('SnapshotArns.member.%d', [*s3_snapshot_location]))
-          end
-
-          if cache_security_groups = options.delete(:security_group_names)
-              req_options.merge!(Fog::AWS.indexed_param('CacheSecurityGroupNames.member.%d', [*cache_security_groups]))
-          end
-
-          if vpc_security_groups = options.delete(:vpc_security_groups)
-              req_options.merge!(Fog::AWS.indexed_param('SecurityGroupIds.member.%d', [*vpc_security_groups]))
-          end
-
-          request( req_options )
-        end
-      end
-
-      class Mock
-        def create_cache_cluster(id, options = {})
-          response        = Excon::Response.new
-          cluster         = { # create an in-memory representation of this cluster
-            'CacheClusterId'  => id.strip,
-            'NumCacheNodes'   => options[:num_nodes]      || 1,
-            'CacheNodeType'   => options[:node_type]      || 'cache.m1.large',
-            'Engine'          => options[:engine]         || 'memcached',
-            'EngineVersion'   => options[:engine_version] || '1.4.5',
-            'CacheClusterStatus'  => 'available',
-            'CacheNodes'          => create_cache_nodes(id.strip, options[:num_nodes]),
-            'CacheSecurityGroups' => [],
-            'CacheParameterGroup' => { 'CacheParameterGroupName' =>
-                options[:parameter_group_name] || 'default.memcached1.4' },
-            'CacheSubnetGroupName' => options[:cache_subnet_group_name],
-            'PendingModifiedValues'       => {},
-            'AutoMinorVersionUpgrade'     =>
-              options[:auto_minor_version_upgrade]    || 'true',
-            'PreferredMaintenanceWindow'  =>
-              options[:preferred_maintenance_window]  || 'sun:05:00-sun:09:00',
-          }
-          self.data[:clusters][id] = cluster  # store the in-memory cluster
-          response.body = {
-            'CacheCluster' => cluster.merge({'CacheClusterStatus' => 'creating'}),
-            'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
-          }
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elasticache/create_cache_parameter_group.rb

@@ -1,52 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/single_parameter_group'
-
-        # creates a cache parameter group
-        #
-        # === Parameters
-        # * name <~String> - The name for the Cache Parameter Group
-        # === Optional Parameters
-        # * description <~String> - The description for the Cache Parameter Group
-        # * family <~String> - The description for the Cache Parameter Group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def create_cache_parameter_group(name, description = name, family = 'memcached1.4')
-          request({
-            'Action' => 'CreateCacheParameterGroup',
-            'CacheParameterGroupName' => name,
-            'Description' => description,
-            'CacheParameterGroupFamily' => family,
-            :parser => Fog::Parsers::AWS::Elasticache::SingleParameterGroup.new
-          })
-        end
-      end
-
-      class Mock
-        def create_cache_parameter_group(name, description = name, family = 'memcached1.4')
-          response = Excon::Response.new
-          if self.data[:parameter_groups] and self.data[:parameter_groups][name]
-            raise Fog::AWS::Elasticache::IdentifierTaken.new("Parameter group #{name} already exists")
-          end
-
-          data = {
-            'CacheParameterGroupName' => name,
-            'CacheParameterGroupFamily' => family.downcase,
-            'Description' => description
-          }
-          self.data[:parameter_groups][name] = data
-
-          response.body = {
-            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-            "CreateCacheParameterGroupResult"=> {"CacheParameterGroup"=> data}
-          }
-          response.status = 200
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elasticache/create_cache_security_group.rb

@@ -1,51 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/single_security_group'
-
-        # creates a cache security group
-        #
-        # === Parameters
-        # * name <~String> - The name for the Cache Security Group
-        # * description <~String> - The description for the Cache Security Group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def create_cache_security_group(name, description = name)
-          request({
-            'Action' => 'CreateCacheSecurityGroup',
-            'CacheSecurityGroupName' => name,
-            'Description' => description,
-            :parser => Fog::Parsers::AWS::Elasticache::SingleSecurityGroup.new
-          })
-        end
-      end
-
-      class Mock
-        def create_cache_security_group(name, description = name)
-          if self.data[:security_groups][name]
-            raise Fog::AWS::Elasticache::IdentifierTaken.new("CacheClusterAlreadyExists => The security group '#{name}' already exists")
-          end
-
-          data = {
-            'CacheSecurityGroupName' => name,
-            'Description' => description,
-            'EC2SecurityGroups' => [],
-            'OwnerId' => '0123456789'
-          }
-          self.data[:security_groups][name] = data
-
-          Excon::Response.new(
-              {
-                  :body => {
-                      'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id },
-                      'CacheSecurityGroup' => data
-                  }
-              }
-          )
-        end
-      end
-    end
-  end
-end