fog-aws 0.0.5

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,51 @@
+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