fog 1.25.0 → 2.0.0

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

@@ -1,60 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/create_cache_subnet_group'
-
-        # Creates a cache subnet group
-        # http://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheSubnetGroup.html
-        #
-        # ==== Parameters
-        # * CacheSubnetGroupName <~String> - A name for the cache subnet group. This value is stored as a lowercase string. Must contain no more than 255 alphanumeric characters or hyphens.
-        # * SubnetIds <~Array> - The VPC subnet IDs for the cache subnet group.
-        # * CacheSubnetGroupDescription <~String> - A description for the cache subnet group.
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def create_cache_subnet_group(name, subnet_ids, description = name)
-          params = {
-            'Action' => 'CreateCacheSubnetGroup',
-            'CacheSubnetGroupName' => name,
-            'CacheSubnetGroupDescription' => description,
-            :parser => Fog::Parsers::AWS::Elasticache::CreateCacheSubnetGroup.new
-          }
-          params.merge!(Fog::AWS.indexed_param("SubnetIds.member", Array(subnet_ids)))
-          request(params)
-        end
-      end
-
-      class Mock
-        def create_cache_subnet_group(name, subnet_ids, description = name)
-          response = Excon::Response.new
-          if self.data[:subnet_groups] && self.data[:subnet_groups][name]
-            raise Fog::AWS::Elasticache::IdentifierTaken.new("CacheSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
-          end
-
-          collection = Fog::Compute[:aws]
-          collection.region = @region
-          subnets = collection.subnets
-
-          subnets = subnet_ids.map { |snid| subnets.get(snid) }
-          vpc_id = subnets.first.vpc_id
-
-          data = {
-            'CacheSubnetGroupName' => name,
-            'CacheSubnetGroupDescription' => description,
-            'SubnetGroupStatus' => 'Complete',
-            'Subnets' => subnet_ids,
-            'VpcId' => vpc_id
-          }
-          self.data[:subnet_groups][name] = data
-          response.body = {
-            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-            'CreateCacheSubnetGroupResult' => { 'CacheSubnetGroup' => data }
-          }
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_cache_clusters'
-
-        # Deletes a Cache Cluster
-        #
-        # === Parameter (required):
-        # *  id <~String> - The ID of the cache cluster to delete
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def delete_cache_cluster(cluster_id)
-          request(
-            'Action'          => 'DeleteCacheCluster',
-            'CacheClusterId'  => cluster_id,
-            :parser => Fog::Parsers::AWS::Elasticache::DescribeCacheClusters.new
-          )
-        end
-      end
-
-      class Mock
-        def delete_cache_cluster(cluster_id)
-          response        = Excon::Response.new
-          cluster         = self.data[:clusters][cluster_id]
-          cluster['CacheClusterStatus'] = 'deleting'
-          response.body = {
-            'CacheClusters'     => self.data[:clusters].values,
-            'ResponseMetadata'  => { 'RequestId' => Fog::AWS::Mock.request_id }
-          }
-          self.data[:clusters].delete(cluster_id)
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/base'
-
-        # deletes a cache parameter group
-        #
-        # === Parameters
-        # * name <~String> - The name for the Cache Parameter Group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def delete_cache_parameter_group(name)
-          request({
-            'Action' => 'DeleteCacheParameterGroup',
-            'CacheParameterGroupName' => name,
-            :parser => Fog::Parsers::AWS::Elasticache::Base.new
-          })
-        end
-      end
-
-      class Mock
-        def delete_cache_parameter_group(name)
-          response = Excon::Response.new
-
-          if self.data[:parameter_groups].delete(name)
-            response.status = 200
-            response.body = {
-              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-            }
-            response
-          else
-            raise Fog::AWS::Elasticache::NotFound.new("CacheParameterGroup not found: #{name}")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/base'
-
-        # deletes a cache security group
-        #
-        # === Parameters
-        # * name <~String> - The name for the Cache Security Group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def delete_cache_security_group(name)
-          request({
-            'Action' => 'DeleteCacheSecurityGroup',
-            'CacheSecurityGroupName' => name,
-            :parser => Fog::Parsers::AWS::Elasticache::Base.new
-          })
-        end
-      end
-
-      class Mock
-        def delete_cache_security_group(name)
-          if self.data[:security_groups].delete(name)
-            Excon::Response.new(
-                {
-                    :status => 200,
-                    :body =>   { 'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id } }
-                }
-            )
-          else
-            raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/base'
-
-        # deletes a cache subnet group
-        #
-        # === Parameters
-        # * name <~String> - The name for the Cache Subnet Group
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def delete_cache_subnet_group(name)
-          request({
-            'Action' => 'DeleteCacheSubnetGroup',
-            'CacheSubnetGroupName' => name,
-            :parser => Fog::Parsers::AWS::Elasticache::Base.new
-          })
-        end
-      end
-
-      class Mock
-        def delete_cache_subnet_group(name)
-          if self.data[:subnet_groups].delete(name)
-            Excon::Response.new(
-                {
-                    :status => 200,
-                    :body =>   { 'ResponseMetadata'=>{ 'RequestId'=> Fog::AWS::Mock.request_id } }
-                }
-            )
-          else
-            raise Fog::AWS::Elasticache::NotFound.new("CacheSubnetGroupNotFound => #{name} not found")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_cache_clusters'
-
-        # Returns a list of Cache Cluster descriptions
-        #
-        # === Parameters (optional)
-        # * id - The ID of an existing cache cluster
-        # * options <~Hash> (optional):
-        # *  :marker <~String> - marker provided in the previous request
-        # *  :max_records <~Integer> - the maximum number of records to include
-        # *  :show_node_info <~Boolean> - whether to show node info
-        # === Returns
-        # * response <~Excon::Response>:
-        #   * body <~Hash>
-        def describe_cache_clusters(id = nil, options = {})
-          request({
-            'Action'            => 'DescribeCacheClusters',
-            'CacheClusterId'    => id,
-            'Marker'            => options[:marker],
-            'MaxRecords'        => options[:max_records],
-            'ShowCacheNodeInfo' => options[:show_node_info],
-            :parser => Fog::Parsers::AWS::Elasticache::DescribeCacheClusters.new
-          })
-        end
-      end
-
-      class Mock
-        def describe_cache_clusters(id = nil, options = {})
-          response        = Excon::Response.new
-          all_clusters    = self.data[:clusters].values.map do |cluster|
-            cluster.merge!(options[:show_node_info] ? {
-              'CacheClusterCreateTime'    => DateTime.now - 60,
-              'PreferredAvailabilityZone' => 'us-east-1a'
-            } : {})
-          end
-          if (id != nil) && (all_clusters.empty?)
-            raise Fog::AWS::Elasticache::NotFound
-          end
-          response.body = {
-            'CacheClusters'     => all_clusters,
-            'ResponseMetadata'  => { 'RequestId' => Fog::AWS::Mock.request_id }
-          }
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_parameter_groups'
-
-        # Returns a list of CacheParameterGroup descriptions
-        #
-        # === Parameters (optional)
-        # * name <~String> - The name of an existing cache parameter group
-        # * options <~Hash> (optional):
-        # *  :marker <~String> - marker provided in the previous request
-        # *  :max_records <~Integer> - the maximum number of records to include
-        def describe_cache_parameter_groups(name = nil, options = {})
-          request({
-            'Action'                  => 'DescribeCacheParameterGroups',
-            'CacheParameterGroupName' => name,
-            'Marker'                  => options[:marker],
-            'MaxRecords'              => options[:max_records],
-            :parser => Fog::Parsers::AWS::Elasticache::DescribeParameterGroups.new
-          }.merge(options))
-        end
-      end
-
-      class Mock
-        def describe_cache_parameter_groups(name = nil, options = {})
-          response = Excon::Response.new
-          parameter_set = []
-          if name
-            if server = self.data[:parameter_groups][name]
-              parameter_set << server
-            else
-              raise Fog::AWS::Elasticache::NotFound.new("CacheParameterGroup #{name} not found")
-            end
-          else
-            parameter_set = self.data[:parameter_groups].values
-          end
-
-          response.status = 200
-
-          response.body = { "CacheParameterGroups" => parameter_set }
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_cache_parameters'
-
-        # Returns a list of CacheParameterGroup descriptions
-        #
-        # === Parameters (optional)
-        # * name <~String> - The name of an existing cache parameter group
-        # * options <~Hash> (optional):
-        # *  :marker <~String> - marker provided in the previous request
-        # *  :max_records <~Integer> - the maximum number of records to include
-        # *  :source <~String> - the parameter types to return.
-        def describe_cache_parameters(name = nil, options = {})
-          request({
-            'Action'                  => 'DescribeCacheParameters',
-            'CacheParameterGroupName' => name,
-            'Marker'                  => options[:marker],
-            'MaxRecords'              => options[:max_records],
-            'Source'                  => options[:source],
-            :parser => Fog::Parsers::AWS::Elasticache::DescribeCacheParameters.new
-          })
-        end
-      end
-
-      class Mock
-        def describe_cache_parameters(name = nil, options = {})
-          Fog::Mock.not_implemented
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_security_groups'
-
-        # Returns a list of CacheSecurityGroup descriptions
-        #
-        # === Parameters (optional)
-        # * name <~String> - The name of an existing cache security group
-        # * options <~Hash> (optional):
-        # *  :marker <~String> - marker provided in the previous request
-        # *  :max_records <~Integer> - the maximum number of records to include
-        def describe_cache_security_groups(name = nil, options = {})
-          request({
-            'Action'                  => 'DescribeCacheSecurityGroups',
-            'CacheSecurityGroupName'  => name,
-            'Marker'                  => options[:marker],
-            'MaxRecords'              => options[:max_records],
-            :parser => Fog::Parsers::AWS::Elasticache::DescribeSecurityGroups.new
-          }.merge(options))
-        end
-      end
-
-      class Mock
-        def describe_cache_security_groups(name = nil, opts={})
-          if name
-            sec_group_set = [self.data[:security_groups][name]].compact
-            raise Fog::AWS::Elasticache::NotFound.new("Security Group #{name} not found") if sec_group_set.empty?
-          else
-            sec_group_set = self.data[:security_groups].values
-          end
-
-          # TODO: refactor to not delete items that we're iterating over. Causes
-          # model tests to fail (currently pending)
-          sec_group_set.each do |sec_group|
-            # TODO: refactor to not delete items that we're iterating over. Causes
-            # model tests to fail (currently pending)
-            sec_group["EC2SecurityGroups"].each do |ec2_secg|
-              if ec2_secg["Status"] == "authorizing" || ec2_secg["Status"] == "revoking"
-                ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
-                if ec2_secg[:tmp] <= Time.now
-                  ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
-                  ec2_secg.delete(:tmp)
-                  sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
-                end
-              end
-            end
-          end
-
-          Excon::Response.new(
-              {
-                  :status => 200,
-                  :body => {
-                      "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-                      "CacheSecurityGroups" => sec_group_set
-                  }
-              }
-          )
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-module Fog
-  module AWS
-    class Elasticache
-      class Real
-        require 'fog/aws/parsers/elasticache/describe_cache_subnet_groups'
-
-        # This API returns a list of CacheSubnetGroup descriptions. If a CacheSubnetGroupName is specified, the list will contain only
-        # the descriptions of the specified CacheSubnetGroup
-        # http://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeCacheSubnetGroups.html
-        # ==== Parameters
-        # * CacheSubnetGroupName <~String> - The name of a specific database subnet group to return details for.
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def describe_cache_subnet_groups(name = nil, opts = {})
-          params = {}
-          if opts[:marker]
-            params['Marker'] = opts[:marker]
-          end
-          if name
-            params['CacheSubnetGroupName'] = name
-          end
-          if opts[:max_records]
-            params['MaxRecords'] = opts[:max_records]
-          end
-
-          request({
-            'Action'  => 'DescribeCacheSubnetGroups',
-            :parser   => Fog::Parsers::AWS::Elasticache::DescribeCacheSubnetGroups.new
-          }.merge(params))
-        end
-      end
-
-      class Mock
-        def describe_cache_subnet_groups(name = nil, opts = {})
-          response = Excon::Response.new
-
-          subnet_group_set = []
-          if name
-            if subnet_group = self.data[:subnet_groups][name]
-              subnet_group_set << subnet_group
-            else
-              raise Fog::AWS::Elasticache::NotFound.new("Subnet Group #{name} not found")
-            end
-          else
-            subnet_group_set = self.data[:subnet_groups].values
-          end
-
-          response.status = 200
-          response.body = {
-            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
-            "DescribeCacheSubnetGroupsResult" => { "CacheSubnetGroups" => subnet_group_set }
-          }
-          response
-        end
-      end
-    end
-  end
-end