fog 1.26.0 → 1.27.0

data/lib/fog/aws/requests/elb/describe_load_balancer_policy_types.rb

@@ -1,66 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/describe_load_balancer_policy_types'
-
-        # Describe all or specified load balancer policy types
-        #
-        # ==== Parameters
-        # * type_name<~Array> - Specifies the name of the policy types. If no names are specified, returns the description of all the policy types defined by Elastic Load Balancing service.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        #     * 'DescribeLoadBalancerPolicyTypesResult'<~Hash>:
-        #       * 'PolicyTypeDescriptions'<~Array>
-        #         * 'Description'<~String> - A human-readable description of the policy type.
-        #         * 'PolicyAttributeTypeDescriptions'<~Array>
-        #           * 'AttributeName'<~String> - The name of the attribute associated with the policy type.
-        #           * 'AttributeValue'<~String> - The type of attribute. For example, Boolean, Integer, etc.
-        #           * 'Cardinality'<~String> - The cardinality of the attribute.
-        #           * 'DefaultValue'<~String> - The default value of the attribute, if applicable.
-        #           * 'Description'<~String> - A human-readable description of the attribute.
-        #         * 'PolicyTypeName'<~String> - The name of the policy type.
-        def describe_load_balancer_policy_types(type_names = [])
-          params = Fog::AWS.indexed_param('PolicyTypeNames.member', [*type_names])
-          request({
-            'Action'  => 'DescribeLoadBalancerPolicyTypes',
-            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancerPolicyTypes.new
-          }.merge!(params))
-        end
-      end
-
-      class Mock
-        def describe_load_balancer_policy_types(type_names = [])
-          type_names = [*type_names]
-          policy_types = if type_names.any?
-            type_names.map do |type_name|
-              policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
-              raise Fog::AWS::ELB::PolicyTypeNotFound unless policy_type
-              policy_type[1].dup
-            end.compact
-          else
-            self.data[:policy_types].map { |policy_type| policy_type.dup }
-          end
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            'ResponseMetadata' => {
-              'RequestId' => Fog::AWS::Mock.request_id
-            },
-            'DescribeLoadBalancerPolicyTypesResult' => {
-              'PolicyTypeDescriptions' => policy_types
-            }
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/describe_load_balancers.rb

@@ -1,137 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/describe_load_balancers'
-
-        # Describe all or specified load balancers
-        #
-        # ==== Parameters
-        # * options<~Hash>
-        #   * 'LoadBalancerNames'<~Array> - List of load balancer names to describe, defaults to all
-        #   * 'Marker'<String> - Indicates where to begin in your list of load balancers
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        #     * 'DescribeLoadBalancersResult'<~Hash>:
-        #       * 'LoadBalancerDescriptions'<~Array>
-        #         * 'AvailabilityZones'<~Array> - list of availability zones covered by this load balancer
-        #         * 'BackendServerDescriptions'<~Array>:
-        #           * 'InstancePort'<~Integer> - the port on which the back-end server is listening
-        #           * 'PolicyNames'<~Array> - list of policy names enabled for the back-end server
-        #         * 'CanonicalHostedZoneName'<~String> - name of the Route 53 hosted zone associated with the load balancer
-        #         * 'CanonicalHostedZoneNameID'<~String> - ID of the Route 53 hosted zone associated with the load balancer
-        #         * 'CreatedTime'<~Time> - time load balancer was created
-        #         * 'DNSName'<~String> - external DNS name of load balancer
-        #         * 'HealthCheck'<~Hash>:
-        #           * 'HealthyThreshold'<~Integer> - number of consecutive health probe successes required before moving the instance to the Healthy state
-        #           * 'Timeout'<~Integer> - number of seconds after which no response means a failed health probe
-        #           * 'Interval'<~Integer> - interval (in seconds) between health checks of an individual instance
-        #           * 'UnhealthyThreshold'<~Integer> - number of consecutive health probe failures that move the instance to the unhealthy state
-        #           * 'Target'<~String> - string describing protocol type, port and URL to check
-        #         * 'Instances'<~Array> - list of instances that the load balancer balances between
-        #         * 'ListenerDescriptions'<~Array>
-        #           * 'PolicyNames'<~Array> - list of policies enabled
-        #           * 'Listener'<~Hash>:
-        #             * 'InstancePort'<~Integer> - port on instance that requests are sent to
-        #             * 'Protocol'<~String> - transport protocol used for routing in [TCP, HTTP]
-        #             * 'LoadBalancerPort'<~Integer> - port that load balancer listens on for requests
-        #         * 'LoadBalancerName'<~String> - name of load balancer
-        #         * 'Policies'<~Hash>:
-        #           * 'LBCookieStickinessPolicies'<~Array> - list of Load Balancer Generated Cookie Stickiness policies for the LoadBalancer
-        #           * 'AppCookieStickinessPolicies'<~Array> - list of Application Generated Cookie Stickiness policies for the LoadBalancer
-        #           * 'OtherPolicies'<~Array> - list of policy names other than the stickiness policies
-        #         * 'SourceSecurityGroup'<~Hash>:
-        #           * 'GroupName'<~String> - Name of the source security group to use with inbound security group rules
-        #           * 'OwnerAlias'<~String> - Owner of the source security group
-        #         * 'NextMarker'<~String> - Marker to specify for next page
-        def describe_load_balancers(options = {})
-          unless options.is_a?(Hash)
-            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
-            options = { 'LoadBalancerNames' => [options].flatten }
-          end
-
-          if names = options.delete('LoadBalancerNames')
-            options.update(Fog::AWS.indexed_param('LoadBalancerNames.member', [*names]))
-          end
-
-          request({
-            'Action'  => 'DescribeLoadBalancers',
-            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def describe_load_balancers(options = {})
-          unless options.is_a?(Hash)
-            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
-            options = { 'LoadBalancerNames' => [options].flatten }
-          end
-
-          lb_names = options['LoadBalancerNames'] || []
-
-          lb_names = [*lb_names]
-          load_balancers = if lb_names.any?
-            lb_names.map do |lb_name|
-              lb = self.data[:load_balancers].find { |name, data| name == lb_name }
-              raise Fog::AWS::ELB::NotFound unless lb
-              lb[1].dup
-            end.compact
-          else
-            self.data[:load_balancers].map { |lb, values| values.dup }
-          end
-
-          marker = options.fetch('Marker', 0).to_i
-          if load_balancers.count - marker > 400
-            next_marker = marker + 400
-            load_balancers = load_balancers[marker...next_marker]
-          else
-            next_marker = nil
-          end
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            'ResponseMetadata' => {
-              'RequestId' => Fog::AWS::Mock.request_id
-            },
-            'DescribeLoadBalancersResult' => {
-              'LoadBalancerDescriptions' => load_balancers.map do |lb|
-                lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }
-                lb['Policies'] = lb['Policies']['Proper'].reduce({'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => [], 'OtherPolicies' => []}) { |m, policy|
-                  case policy['PolicyTypeName']
-                  when 'AppCookieStickinessPolicyType'
-                    cookie_name = policy['PolicyAttributeDescriptions'].find{|h| h['AttributeName'] == 'CookieName'}['AttributeValue']
-                    m['AppCookieStickinessPolicies'] << { 'PolicyName' => policy['PolicyName'], 'CookieName' => cookie_name }
-                  when 'LBCookieStickinessPolicyType'
-                    cookie_expiration_period = policy['PolicyAttributeDescriptions'].find{|h| h['AttributeName'] == 'CookieExpirationPeriod'}['AttributeValue'].to_i
-                    lb_policy = { 'PolicyName' => policy['PolicyName'] }
-                    lb_policy['CookieExpirationPeriod'] = cookie_expiration_period if cookie_expiration_period > 0
-                    m['LBCookieStickinessPolicies'] << lb_policy
-                  else
-                    m['OtherPolicies'] << policy['PolicyName']
-                  end
-                  m
-                }
-
-                lb['BackendServerDescriptions'] = lb.delete('BackendServerDescriptionsRemote')
-                lb
-              end
-            }
-          }
-
-          if next_marker
-            response.body['DescribeLoadBalancersResult']['NextMarker'] = next_marker.to_s
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/describe_tags.rb

@@ -1,56 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-
-        require 'fog/aws/parsers/elb/tag_list_parser'
-
-        # returns a Hash of tags for a load balancer
-        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DescribeTags.html
-        # ==== Parameters
-        # * elb_id <~String> - name(s) of the ELB instance whose tags are to be retrieved (allows 1-20 of them)
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        def describe_tags(elb_ids)
-          request({
-              'Action' => 'DescribeTags',
-              :parser  => Fog::Parsers::AWS::ELB::TagListParser.new
-            }.merge(Fog::AWS.indexed_param('LoadBalancerNames.member.%d', elb_ids))
-          )
-        end
-        # def describe_tags(filters = {})
-        #   params = Fog::AWS.indexed_filters(filters)
-        #   request({
-        #     'Action'    => 'DescribeTags',
-        #     :idempotent => true,
-        #     :parser     => Fog::Parsers::Compute::AWS::DescribeTags.new
-        #   }.merge!(params))
-        # end
-
-      end
-
-      class Mock
-
-        def describe_tags(elb_id)
-          response = Excon::Response.new
-
-          if server = self.data[:load_balancers][elb_id]
-            response.status = 200
-            ##{"DescribeTagsResult"=>{"LoadBalancers"=>[{"Tags"=>{"Name"=>"2esakowski-test-opsworks-elb"}, "LoadBalancerName"=>"esakowski-test-opsworks"}]}}
-            response.body = {"DescribeTagsResult"=>{"LoadBalancers"=>[{"Tags"=>self.data[:tags][elb_id], "LoadBalancerName"=>elb_id}]}}
-
-#            response.body = {
-#              "DescribeTagsResult" =>
-#               {"TagDescriptions" => self.data[:tags][elb_id]}
-#            }
-            response
-          else
-            raise Fog::AWS::ELB::NotFound.new("Elastic load balancer #{elb_id} not found")
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/detach_load_balancer_from_subnets.rb

@@ -1,58 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/detach_load_balancer_from_subnets'
-
-        # Disable a subnet for an existing ELB
-        #
-        # ==== Parameters
-        # * subnet_ids<~Array> - List of subnet ids to enable on ELB
-        # * lb_name<~String> - Load balancer to disable availability zones on
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        #     * 'DetachLoadBalancerFromSubnetsResult'<~Hash>:
-        #       * 'Subnets'<~Array> - array of strings describing the subnet ids currently enabled
-        def detach_load_balancer_from_subnets(subnet_ids, lb_name)
-          params = Fog::AWS.indexed_param('Subnets.member', [*subnet_ids])
-          request({
-            'Action'           => 'DetachLoadBalancerFromSubnets',
-            'LoadBalancerName' => lb_name,
-            :parser            => Fog::Parsers::AWS::ELB::DetachLoadBalancerFromSubnets.new
-          }.merge!(params))
-        end
-
-        alias_method :disable_subnets, :detach_load_balancer_from_subnets
-      end
-
-      class Mock
-        def detach_load_balancer_from_subnets(subnet_ids, lb_name)
-          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          load_balancer['Subnets'] << subnet_ids
-          load_balancer['Subnets'].flatten!.uniq!
-
-          response.body = {
-            'ResponseMetadata' => {
-              'RequestId' => Fog::AWS::Mock.request_id
-            },
-            'DetachLoadBalancerFromSubnetsResult' => {
-              'Subnets' => load_balancer['Subnets']
-            }
-          }
-
-          response
-        end
-
-        alias_method :disable_subnets, :detach_load_balancer_from_subnets
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb

@@ -1,57 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/disable_availability_zones_for_load_balancer'
-
-        # Disable an availability zone for an existing ELB
-        #
-        # ==== Parameters
-        # * availability_zones<~Array> - List of availability zones to disable on ELB
-        # * lb_name<~String> - Load balancer to disable availability zones on
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        #     * 'DisableAvailabilityZonesForLoadBalancerResult'<~Hash>:
-        #       * 'AvailabilityZones'<~Array> - A list of updated Availability Zones for the LoadBalancer.
-        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
-          request({
-            'Action'           => 'DisableAvailabilityZonesForLoadBalancer',
-            'LoadBalancerName' => lb_name,
-            :parser            => Fog::Parsers::AWS::ELB::DisableAvailabilityZonesForLoadBalancer.new
-          }.merge!(params))
-        end
-
-        alias_method :disable_zones, :disable_availability_zones_for_load_balancer
-      end
-
-      class Mock
-        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          load_balancer['AvailabilityZones'].delete_if { |az| availability_zones.include? az }
-
-          response.body = {
-            'ResponseMetadata' => {
-              'RequestId' => Fog::AWS::Mock.request_id
-            },
-            'DisableAvailabilityZonesForLoadBalancerResult' => {
-              'AvailabilityZones' => load_balancer['AvailabilityZones']
-            }
-          }
-
-          response
-        end
-
-        alias_method :disable_zones, :disable_availability_zones_for_load_balancer
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb

@@ -1,58 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/enable_availability_zones_for_load_balancer'
-
-        # Enable an availability zone for an existing ELB
-        #
-        # ==== Parameters
-        # * availability_zones<~Array> - List of availability zones to enable on ELB
-        # * lb_name<~String> - Load balancer to enable availability zones on
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        #     * 'EnableAvailabilityZonesForLoadBalancerResult'<~Hash>:
-        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
-        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
-          request({
-            'Action'           => 'EnableAvailabilityZonesForLoadBalancer',
-            'LoadBalancerName' => lb_name,
-            :parser            => Fog::Parsers::AWS::ELB::EnableAvailabilityZonesForLoadBalancer.new
-          }.merge!(params))
-        end
-
-        alias_method :enable_zones, :enable_availability_zones_for_load_balancer
-      end
-
-      class Mock
-        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
-          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          load_balancer['AvailabilityZones'] << availability_zones
-          load_balancer['AvailabilityZones'].flatten!.uniq!
-
-          response.body = {
-            'ResponseMetadata' => {
-              'RequestId' => Fog::AWS::Mock.request_id
-            },
-            'EnableAvailabilityZonesForLoadBalancerResult' => {
-              'AvailabilityZones' => load_balancer['AvailabilityZones']
-            }
-          }
-
-          response
-        end
-
-        alias_method :enable_zones, :enable_availability_zones_for_load_balancer
-      end
-    end
-  end
-end

data/lib/fog/aws/requests/elb/modify_load_balancer_attributes.rb

@@ -1,65 +0,0 @@
-module Fog
-  module AWS
-    class ELB
-      class Real
-        require 'fog/aws/parsers/elb/empty'
-
-        # Sets attributes of the load balancer
-        #
-        # The following attributes can be set:
-        # * CrossZoneLoadBalancing (enable/disable)
-        # * ConnectionDraining (enable/disable and timeout)
-        # * Idle Connection Timeouts
-        #
-        # Still requires: AccessLog configuration
-        #
-        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_ModifyLoadBalancerAttributes.html
-        # ==== Parameters
-        # * lb_name<~String> - Name of the ELB
-        # * options<~Hash>
-        #   * 'ConnectionDraining'<~Hash>:
-        #     * 'Enabled'<~Boolean> whether to enable connection draining
-        #     * 'Timeout'<~Integer> max time to keep existing conns open before deregistering instances
-        #   * 'CrossZoneLoadBalancing'<~Hash>:
-        #     * 'Enabled'<~Boolean> whether to enable cross zone load balancing
-        #   * 'ConnectionSettings'<~Hash>:
-        #     * 'IdleTimeout'<~Integer> time (in seconds) the connection is allowed to be idle (no data has been sent over the connection) before it is closed by the load balancer.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'ResponseMetadata'<~Hash>:
-        #       * 'RequestId'<~String> - Id of request
-        def modify_load_balancer_attributes(lb_name, options)
-          attributes = Fog::AWS.serialize_keys 'LoadBalancerAttributes', options
-          request(attributes.merge(
-            'Action'           => 'ModifyLoadBalancerAttributes',
-            'LoadBalancerName' => lb_name,
-            :parser            => Fog::Parsers::AWS::ELB::Empty.new
-          ))
-        end
-      end
-
-      class Mock
-        def modify_load_balancer_attributes(lb_name, attributes)
-          raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
-
-          if attributes['CrossZoneLoadBalancing'] || attributes['ConnectionDraining'] || attributes['ConnectionSettings']
-            load_balancer['LoadBalancerAttributes'].merge! attributes
-          end
-
-          response = Excon::Response.new
-
-          response.status = 200
-          response.body = {
-            "ResponseMetadata" => {
-              "RequestId" => Fog::AWS::Mock.request_id
-            }
-          }
-
-          response
-        end
-      end
-    end
-  end
-end