fog-aws 0.0.5

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/apply_security_groups_to_load_balancer'
+
+        # Sets the security groups for an ELB in VPC
+        #
+        # ==== Parameters
+        # * security_group_ids<~Array> - List of security group 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
+        #     * 'ApplySecurityGroupsToLoadBalancer'<~Hash>:
+        #       * 'SecurityGroups'<~Array> - array of strings describing the security group ids currently enabled
+        def apply_security_groups_to_load_balancer(security_group_ids, lb_name)
+          params = Fog::AWS.indexed_param('SecurityGroups.member', [*security_group_ids])
+          request({
+            'Action'           => 'ApplySecurityGroupsToLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::ApplySecurityGroupsToLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias_method :apply_security_groups, :apply_security_groups_to_load_balancer
+      end
+
+      class Mock
+        def apply_security_groups_to_load_balancer(security_group_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['SecurityGroups'] << security_group_ids
+          load_balancer['SecurityGroups'].flatten!.uniq!
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DetachLoadBalancerFromSubnetsResult' => {
+              'SecurityGroups' => load_balancer['SecurityGroups']
+            }
+          }
+
+          response
+        end
+
+      alias_method :apply_security_groups, :apply_security_groups_to_load_balancer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/attach_load_balancer_to_subnets'
+
+        # Enable a subnet for an existing ELB
+        #
+        # ==== Parameters
+        # * subnet_ids<~Array> - List of subnet ids 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
+        #     * 'AttachLoadBalancerToSubnetsResult'<~Hash>:
+        #       * 'Subnets'<~Array> - array of strings describing the subnet ids currently enabled
+        def attach_load_balancer_to_subnets(subnet_ids, lb_name)
+          params = Fog::AWS.indexed_param('Subnets.member', [*subnet_ids])
+          request({
+            'Action'           => 'AttachLoadBalancerToSubnets',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::AttachLoadBalancerToSubnets.new
+          }.merge!(params))
+        end
+
+        alias_method :enable_subnets, :attach_load_balancer_to_subnets
+      end
+
+      class Mock
+        def attach_load_balancer_to_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
+            },
+            'AttachLoadBalancerToSubnetsResult' => {
+              'Subnets' => load_balancer['Subnets']
+            }
+          }
+
+          response
+        end
+
+        alias_method :enable_subnets, :attach_load_balancer_to_subnets
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/configure_health_check'
+
+        # Enables the client to define an application healthcheck for the instances.
+        # See http://docs.amazonwebservices.com/ElasticLoadBalancing/latest/APIReference/index.html?API_ConfigureHealthCheck.html
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * health_check<~Hash> - A hash of parameters describing the health check
+        #   * 'HealthyThreshold'<~Integer> - Specifies the number of consecutive
+        #     health probe successes required before moving the instance to the Healthy state.
+        #   * 'Interval'<~Integer> - Specifies the approximate interval, in seconds,
+        #     between health checks of an individual instance.
+        #   * 'Target'<~String> - Specifies the instance being checked.
+        #     The protocol is either TCP or HTTP. The range of valid ports is one (1) through 65535.
+        #   * 'Timeout'<~Integer> - Specifies the amount of time, in seconds,
+        #   during which no response means a failed health probe.
+        #   * 'UnhealthyThreshold'<~Integer> - Specifies the number of consecutive
+        #     health probe failures required before moving the instance to the Unhealthy state.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def configure_health_check(lb_name, health_check)
+          params = {'LoadBalancerName' => lb_name}
+          health_check.each {|key, value| params["HealthCheck.#{key}"] = value }
+
+          request({
+            'Action'           => 'ConfigureHealthCheck',
+            :parser            => Fog::Parsers::AWS::ELB::ConfigureHealthCheck.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def configure_health_check(lb_name, health_check)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            load_balancer['HealthCheck'] = health_check
+
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              },
+              'ConfigureHealthCheckResult' => {
+                'HealthCheck' => load_balancer['HealthCheck']
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/empty'
+
+        # Create an app cookie stickiness policy
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * policy_name<~String> - The name of the policy being created.
+        #   The name must be unique within the set of policies for this Load Balancer.
+        # * cookie_name<~String> - Name of the application cookie used for stickiness.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def create_app_cookie_stickiness_policy(lb_name, policy_name, cookie_name)
+          params = {'CookieName' => cookie_name, 'PolicyName' => policy_name}
+
+          request({
+            'Action'           => 'CreateAppCookieStickinessPolicy',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_app_cookie_stickiness_policy(lb_name, policy_name, cookie_name)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
+
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/empty'
+
+        # Create a Load Balancer Cookie Stickiness Policy
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * policy_name<~String> - The name of the policy being created. The name
+        #   must be unique within the set of policies for this Load Balancer.
+        # * cookie_expiration_period<~Integer> - The time period in seconds after
+        #   which the cookie should be considered stale. Not specifying this
+        #   parameter indicates that the sticky session will last for the duration of the browser session.
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def create_lb_cookie_stickiness_policy(lb_name, policy_name, cookie_expiration_period=nil)
+          params = {'PolicyName' => policy_name, 'CookieExpirationPeriod' => cookie_expiration_period}
+
+          request({
+            'Action'           => 'CreateLBCookieStickinessPolicy',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::Empty.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_lb_cookie_stickiness_policy(lb_name, policy_name, cookie_expiration_period=nil)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            response = Excon::Response.new
+            response.status = 200
+
+            create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
+
+            response.body = {
+              'ResponseMetadata' => {
+                'RequestId' => Fog::AWS::Mock.request_id
+              }
+            }
+
+            response
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+        require 'fog/aws/parsers/elb/create_load_balancer'
+
+        # Create a new Elastic Load Balancer
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones for the ELB
+        # * lb_name<~String> - Name for the new ELB -- must be unique
+        # * listeners<~Array> - Array of Hashes describing ELB listeners to assign to the ELB
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP, HTTPS, TCP or SSL.
+        #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
+        #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        #   * 'InstanceProtocol'<~String> - Protocol for sending traffic to an instance. Either HTTP, HTTPS, TCP or SSL.
+        #   * 'SSLCertificateId'<~String> - ARN of the server certificate
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'CreateLoadBalancerResult'<~Hash>:
+        #       * 'DNSName'<~String> - DNS name for the newly created ELB
+        def create_load_balancer(availability_zones, lb_name, listeners, options = {})
+          params = Fog::AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
+          params.merge!(Fog::AWS.indexed_param('Subnets.member.%d', options[:subnet_ids]))
+          params.merge!(Fog::AWS.serialize_keys('Scheme', options[:scheme]))
+          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups]))
+
+          listener_protocol = []
+          listener_lb_port = []
+          listener_instance_port = []
+          listener_instance_protocol = []
+          listener_ssl_certificate_id = []
+          listeners.each do |listener|
+            listener_protocol.push(listener['Protocol'])
+            listener_lb_port.push(listener['LoadBalancerPort'])
+            listener_instance_port.push(listener['InstancePort'])
+            listener_instance_protocol.push(listener['InstanceProtocol'])
+            listener_ssl_certificate_id.push(listener['SSLCertificateId'])
+          end
+
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.InstanceProtocol', listener_instance_protocol))
+          params.merge!(Fog::AWS.indexed_param('Listeners.member.%d.SSLCertificateId', listener_ssl_certificate_id))
+
+          request({
+            'Action'           => 'CreateLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::CreateLoadBalancer.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_load_balancer(availability_zones, lb_name, listeners = [], options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          raise Fog::AWS::ELB::IdentifierTaken if self.data[:load_balancers].key? lb_name
+
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
+
+          listeners = [*listeners].map do |listener|
+            if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
+              raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
+            end
+            {'Listener' => listener, 'PolicyNames' => []}
+          end
+
+          dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
+
+          availability_zones = [*availability_zones].compact
+          region = availability_zones.empty? ? "us-east-1" : availability_zones.first.gsub(/[a-z]$/, '')
+          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
+          subnet_ids = options[:subnet_ids] || []
+          subnets = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
+
+          # http://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/default-vpc.html
+          elb_location = if supported_platforms.include?("EC2")
+                           if subnet_ids.empty?
+                             'EC2-Classic'
+                           else
+                             'EC2-VPC'
+                           end
+                         else
+                           if subnet_ids.empty?
+                             'EC2-VPC-Default'
+                           else
+                             'VPC'
+                           end
+                         end
+
+          security_group = case elb_location
+                           when 'EC2-Classic'
+                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
+                           when 'EC2-VPC-Default'
+                             # find or create default vpc
+                             compute = Fog::Compute::AWS::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
+                             unless vpc = compute.vpcs.all.first
+                               vpc = compute.vpcs.create('cidr_block' => '10.0.0.0/24')
+                             end
+
+                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+                               sg['groupName'] =~ /^default_elb/ &&
+                                 sg["vpcId"] == vpc.id
+                             }
+
+                             unless default_sg
+                               default_sg = {
+                                             'groupDescription'    => 'default_elb security group',
+                                             'groupName'           => "default_elb_#{Fog::Mock.random_hex(6)}",
+                                             'groupId'             => Fog::AWS::Mock.security_group_id,
+                                             'ipPermissionsEgress' => [],
+                                             'ipPermissions'       => [],
+                                             'ownerId'             => self.data[:owner_id],
+                                             'vpcId'               => vpc.id
+                                            }
+                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
+                             end
+
+                             default_sg
+                           when 'EC2-VPC'
+                             # find or create default vpc security group
+                             vpc_id = subnets.first["vpcId"]
+                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+                               sg['groupName'] == 'default' &&
+                                 sg["vpcId"] == vpc_id
+                             }
+
+                             unless default_sg
+                               default_sg = {
+                                             'groupDescription'    => 'default elb security group',
+                                             'groupName'           => 'default',
+                                             'groupId'             => Fog::AWS::Mock.security_group_id,
+                                             'ipPermissionsEgress' => [],
+                                             'ipPermissions'       => [],
+                                             'ownerId'             => self.data[:owner_id],
+                                             'vpcId'               => vpc_id
+                                            }
+                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['default'] = default_sg
+                             end
+
+                             default_sg
+                           end
+          self.data[:tags] ||= {}
+          self.data[:tags][lb_name] = {}
+
+          self.data[:load_balancers][lb_name] = {
+            'AvailabilityZones' => availability_zones,
+            'BackendServerDescriptions' => [],
+            # Hack to facilitate not updating the local data structure
+            # (BackendServerDescriptions) until we do a subsequent
+            # describe as that is how AWS behaves.
+            'BackendServerDescriptionsRemote' => [],
+            'Subnets' => options[:subnet_ids] || [],
+            'Scheme' => options[:scheme].nil? ? 'internet-facing' : options[:scheme],
+            'SecurityGroups' => options[:security_groups].nil? ? [] : options[:security_groups],
+            'CanonicalHostedZoneName' => '',
+            'CanonicalHostedZoneNameID' => '',
+            'CreatedTime' => Time.now,
+            'DNSName' => dns_name,
+            'HealthCheck' => {
+              'HealthyThreshold' => 10,
+              'Timeout' => 5,
+              'UnhealthyThreshold' => 2,
+              'Interval' => 30,
+              'Target' => 'TCP:80'
+            },
+            'Instances' => [],
+            'ListenerDescriptions' => listeners,
+            'LoadBalancerAttributes' => {
+              'ConnectionDraining' => {'Enabled' => false, 'Timeout' => 300},
+              'CrossZoneLoadBalancing' => {'Enabled' => false},
+              'ConnectionSettings' => {'IdleTimeout' => 60}
+            },
+            'LoadBalancerName' => lb_name,
+            'Policies' => {
+              'AppCookieStickinessPolicies' => [],
+              'LBCookieStickinessPolicies' => [],
+              'OtherPolicies' => [],
+              'Proper' => []
+            },
+            'SourceSecurityGroup' => {
+              'GroupName' => security_group['groupName'],
+              'OwnerAlias' => ''
+            }
+          }
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'CreateLoadBalancerResult' => {
+              'DNSName' => dns_name
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end