fog 1.14.0 → 1.15.0

data/lib/fog/aws/parsers/rds/db_parser.rb

@@ -33,6 +33,11 @@ module Fog
             when 'DBParameterGroups'
               @in_db_parameter_groups = true
               @db_parameter_groups = []
+            when 'VpcSecurityGroupMembership'
+              @vpc_security_group = {}
+            when 'VpcSecurityGroups'
+              @in_vpc_security_groups = true
+              @vpc_security_groups = []
             end
             
           end
@@ -47,9 +52,9 @@ module Fog
               'DBInstanceStatus', 'DBInstanceIdentifier', 'EngineVersion', 
               'PreferredBackupWindow', 'PreferredMaintenanceWindow', 
               'AvailabilityZone', 'MasterUsername', 'DBName', 'LicenseModel',
-              'DBSubnetGroupName', 'PubliclyAccessible'
+              'DBSubnetGroupName'
               @db_instance[name] = value
-            when 'MultiAZ', 'AutoMinorVersionUpgrade'
+            when 'MultiAZ', 'AutoMinorVersionUpgrade', 'PubliclyAccessible'
               if value == 'false'
                 @db_instance[name] = false
               else
@@ -81,20 +86,37 @@ module Fog
             when 'DBSecurityGroups'
               @in_db_security_groups = false
               @db_instance['DBSecurityGroups'] = @db_security_groups
-            when 'Status', 'DBSecurityGroupName'
-              if @in_db_security_groups
-                @db_security_group[name]=value
-              end
+            when 'DBSecurityGroupName'
+              @db_security_group[name]=value
             when 'DBSecurityGroup'
               @db_security_groups << @db_security_group
               @db_security_group = {}
             
+            when 'VpcSecurityGroups'
+              @in_vpc_security_groups = false
+              @db_instance['VpcSecurityGroups'] = @vpc_security_groups
+            when 'VpcSecurityGroupMembership'
+              @vpc_security_groups << @vpc_security_group
+              @vpc_security_group = {}
+            when 'VpcSecurityGroupId'
+              @vpc_security_group[name] = value
             when 'AllocatedStorage'
               if @in_pending_modified_values
                 @pending_modified_values[name] = value.to_i
               else
                 @db_instance[name] = value.to_i
               end
+
+            when 'Status'
+              # Unfortunately, status is used in VpcSecurityGroupMemebership and
+              # DBSecurityGroups
+              if @in_db_security_groups
+                @db_security_group[name]=value
+              end
+              if @in_vpc_security_groups
+                @vpc_security_group[name] = value
+              end
+
             when 'Address'
               @endpoint[name] = value
             when 'Port'

data/lib/fog/aws/parsers/rds/describe_orderable_db_instance_options.rb

@@ -0,0 +1,47 @@
+module Fog
+  module Parsers
+    module AWS
+      module RDS
+
+        class DescribeOrderableDBInstanceOptions < Fog::Parsers::Base
+
+          def reset
+            @response = { 'DescribeOrderableDBInstanceOptionsResult' => {'OrderableDBInstanceOptions' => []}, 'ResponseMetadata' => {} }
+            @db_instance_option = {}
+            @db_instance_options = []
+          end
+
+          def start_element(name, attrs = [])
+            case name
+            when 'AvailabilityZones' then @availability_zones = []
+            when 'AvailabilityZone' then @availability_zone = {}
+            end
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'MultiAZCapable', 'ReadReplicaCapable', 'Vpc' then @db_instance_option[name] = to_boolean(value)
+            when 'Engine', 'LicenseModel', 'EngineVersion', 'DBInstanceClass' then @db_instance_option[name] = value
+            when 'AvailabilityZones' then @db_instance_option[name] = @availability_zones
+            when 'AvailabilityZone' then @availability_zones << @availability_zone unless @availability_zone.empty?
+            when 'Name' then @availability_zone[name] = value
+            when 'ProvisionedIopsCapable' then @availability_zone[name] = to_boolean(value)
+            when 'OrderableDBInstanceOption'
+              @db_instance_options << @db_instance_option
+              @db_instance_option = {}
+            when 'OrderableDBInstanceOptions'
+              @response['DescribeOrderableDBInstanceOptionsResult']['OrderableDBInstanceOptions'] = @db_instance_options
+            when 'Marker' then @response['DescribeOrderableDBInstanceOptionsResult'][name] = value
+            when 'RequestId' then @response['ResponseMetadata'][name] = value
+            end
+          end
+
+          def to_boolean(v)
+            (v =~ /\A\s*(true|yes|1|y)\s*$/i) == 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/rds.rb

@@ -51,6 +51,8 @@ module Fog
       request :describe_db_subnet_groups
       # TODO: :delete_db_subnet_group, :modify_db_subnet_group
 
+      request :describe_orderable_db_instance_options
+
       request :describe_db_log_files
       request :download_db_logfile_portion
 
@@ -73,6 +75,9 @@ module Fog
       model       :subnet_group
       collection  :subnet_groups
 
+      model       :instance_option
+      collection  :instance_options
+
       model       :log_file
       collection  :log_files
 

data/lib/fog/aws/requests/auto_scaling/describe_auto_scaling_groups.rb

@@ -111,7 +111,15 @@ module Fog
 
         def describe_auto_scaling_groups(options = {})
           results = { 'AutoScalingGroups' => [] }
-          self.data[:auto_scaling_groups].each do |asg_name, asg_data|
+          asg_set = self.data[:auto_scaling_groups]
+
+          if !options["AutoScalingGroupNames"].nil?
+            asg_set = asg_set.reject do |asg_name, asg_data|
+              ![*options["AutoScalingGroupNames"]].include?(asg_name)
+            end
+          end
+
+          asg_set.each do |asg_name, asg_data|
             results['AutoScalingGroups'] << {
               'AutoScalingGroupName' => asg_name
             }.merge!(asg_data)

data/lib/fog/aws/requests/auto_scaling/describe_policies.rb

@@ -76,7 +76,21 @@ module Fog
 
         def describe_policies(options = {})
           results = { 'ScalingPolicies' => [] }
-          self.data[:scaling_policies].each do |asp_name, asp_data|
+          policy_set = self.data[:scaling_policies]
+
+          for opt_key, opt_value in options
+            if opt_key == "PolicyNames" && opt_value != nil && opt_value != ""
+              policy_set = policy_set.reject do |asp_name, asp_data|
+                ![*options["PolicyNames"]].include?(asp_name)
+              end
+            elsif opt_key == "AutoScalingGroupName" && opt_value != nil && opt_value != ""
+              policy_set = policy_set.reject do |asp_name, asp_data|
+                options["AutoScalingGroupName"] != asp_data["AutoScalingGroupName"]
+              end
+            end
+          end
+
+          policy_set.each do |asp_name, asp_data|
             results['ScalingPolicies'] << {
               'PolicyName' => asp_name
             }.merge!(asp_data)

data/lib/fog/aws/requests/compute/describe_account_attributes.rb

@@ -0,0 +1,49 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/describe_account_attributes'
+
+        # Describe account attributes
+        #
+        # ==== Parameters
+        # * filters<~Hash> - List of filters to limit results with
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> = Id of request
+        #     * 'accountAttributeSet'<~Array>:
+        #       * 'attributeName'<~String> - supported-platforms
+        #       * 'attributeValueSet'<~Array>:
+        #         * 'attributeValue'<~String> - Value of attribute
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-DescribeAccountAttributes.html]
+
+        def describe_account_attributes(filters = {})
+          params = Fog::AWS.indexed_filters(filters)
+          request({
+            'Action'    => 'DescribeAccountAttributes',
+            :idempotent => true,
+            :parser     => Fog::Parsers::Compute::AWS::DescribeAccountAttributes.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def describe_account_attributes(filters = {})
+          account_attributes = self.data[:account_attributes]
+
+          Excon::Response.new(
+            :status => 200,
+            :body => {
+              'requestId'           => Fog::AWS::Mock.request_id,
+              'accountAttributeSet' => account_attributes
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -35,8 +35,6 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['AppCookieStickinessPolicies'] << { 'CookieName' => cookie_name, 'PolicyName' => policy_name }
-
             create_load_balancer_policy(lb_name, policy_name, 'AppCookieStickinessPolicyType', {'CookieName' => cookie_name})
 
             response.body = {

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

@@ -37,8 +37,6 @@ module Fog
             response = Excon::Response.new
             response.status = 200
 
-            load_balancer['Policies']['LBCookieStickinessPolicies'] << { 'CookieExpirationPeriod' => cookie_expiration_period, 'PolicyName' => policy_name }
-
             create_load_balancer_policy(lb_name, policy_name, 'LBCookieStickinessPolicyType', {'CookieExpirationPeriod' => cookie_expiration_period})
 
             response.body = {

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

@@ -74,17 +74,37 @@ module Fog
 
           dns_name = Fog::AWS::ELB::Mock.dns_name(lb_name, @region)
 
-          Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:security_groups]['amazon-elb-sg'] ||= {
-            'groupDescription'   => 'amazon-elb-sg',
-            'groupName'          => 'amazon-elb-sg',
-            'groupId'            => 'amazon-elb',
-            'ownerId'            => 'amazon-elb',
-            'ipPermissionsEgree' => [],
-            'ipPermissions'      => [],
-          }
+          region = availability_zones ? availability_zones.first.gsub(/[a-z]$/, '') : "us-east-1"
+          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].detect { |h| h["attributeName"] == "supported-platforms" }["values"]
+          security_group = if supported_platforms.include?("EC2")
+                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
+                           else
+                             if default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.detect { |sg| sg['groupName'] =~ /default_elb/ }
+                               default_sg
+                             else
+                               default_sg_name   = "default_elb_#{Fog::Mock.random_hex(6)}"
+                               default_sg = {
+                                 'groupDescription'    => 'default elb security group',
+                                 'groupName'           => default_sg_name,
+                                 'groupId'             => Fog::AWS::Mock.security_group_id,
+                                 'ipPermissionsEgress' => [],
+                                 'ipPermissions'       => [],
+                                 'ownerId'             => self.data[:owner_id]
+                               }
+                               Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups][default_sg_name] = default_sg
+                             end
+                             default_sg
+                           end
+
+
 
           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],
@@ -105,10 +125,11 @@ module Fog
             'Policies' => {
               'AppCookieStickinessPolicies' => [],
               'LBCookieStickinessPolicies' => [],
+              'OtherPolicies' => [],
               'Proper' => []
             },
             'SourceSecurityGroup' => {
-              'GroupName' => '',
+              'GroupName' => security_group['groupName'],
               'OwnerAlias' => ''
             }
           }

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

@@ -33,12 +33,12 @@ module Fog
           params.merge!(Fog::AWS.indexed_param('PolicyAttributes.member.%d.AttributeValue', attribute_value))
 
           request({
-            'Action'           => 'CreateLoadBalancerPolicy',
-            'LoadBalancerName' => lb_name,
-            'PolicyName'       => name,
-            'PolicyTypeName'   => type_name,
-            :parser            => Fog::Parsers::AWS::ELB::Empty.new
-          }.merge!(params))
+                    'Action'           => 'CreateLoadBalancerPolicy',
+                    'LoadBalancerName' => lb_name,
+                    'PolicyName'       => name,
+                    'PolicyTypeName'   => type_name,
+                    :parser            => Fog::Parsers::AWS::ELB::Empty.new
+                  }.merge!(params))
         end
 
       end
@@ -46,12 +46,15 @@ module Fog
       class Mock
         def create_load_balancer_policy(lb_name, name, type_name, attributes = {})
           if load_balancer = self.data[:load_balancers][lb_name]
-            raise Fog::AWS::IAM::DuplicatePolicyName if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
-            raise Fog::AWS::IAM::PolicyTypeNotFound unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
+            raise Fog::AWS::ELB::DuplicatePolicyName, name if policy = load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == name }
+            raise Fog::AWS::ELB::PolicyTypeNotFound, type_name unless policy_type = self.data[:policy_types].find { |pt| pt['PolicyTypeName'] == type_name }
 
             response = Excon::Response.new
 
             attributes = attributes.map do |key, value|
+              if key == "CookieExpirationPeriod" && !value
+                value = 0
+              end
               {"AttributeName" => key, "AttributeValue" => value.to_s}
             end
 

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

@@ -20,6 +20,9 @@ module Fog
         #     * '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
@@ -41,6 +44,7 @@ module Fog
         #         * '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
@@ -101,7 +105,23 @@ module Fog
             'DescribeLoadBalancersResult' => {
               'LoadBalancerDescriptions' => load_balancers.map do |lb|
                 lb['Instances'] = lb['Instances'].map { |i| i['InstanceId'] }
-                lb['Policies'] = lb['Policies'].reject { |name, policies| name == 'Proper' }
+                lb['Policies'] = lb['Policies']['Proper'].inject({'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => [], 'OtherPolicies' => []}) { |m, policy|
+                  case policy['PolicyTypeName']
+                  when 'AppCookieStickinessPolicyType'
+                    cookie_name = policy['PolicyAttributeDescriptions'].detect{|h| h['AttributeName'] == 'CookieName'}['AttributeValue']
+                    m['AppCookieStickinessPolicies'] << { 'PolicyName' => policy['PolicyName'], 'CookieName' => cookie_name }
+                  when 'LBCookieStickinessPolicyType'
+                    cookie_expiration_period = policy['PolicyAttributeDescriptions'].detect{|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
             }

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

@@ -0,0 +1,67 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/empty'
+
+        # Replaces the current set of policies associated with a port on which the back-end server is listening with a new set of policies.
+        # After the policies have been created using CreateLoadBalancerPolicy, they can be applied here as a list.
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB
+        # * instance_port<~Integer> - The port on the instance that the ELB will forward traffic to
+        # * policy_names<~Array> - Array of Strings listing the policies to set for the backend port
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def set_load_balancer_policies_for_backend_server(lb_name, instance_port, policy_names)
+          params = {'InstancePort' => instance_port}
+          if policy_names.any?
+            params.merge!(Fog::AWS.indexed_param('PolicyNames.member', policy_names))
+          else
+            params['PolicyNames'] = ''
+          end
+
+          request({ 'Action' => 'SetLoadBalancerPoliciesForBackendServer',
+                    'LoadBalancerName' => lb_name,
+                    :parser => Fog::Parsers::AWS::ELB::Empty.new
+                  }.merge!(params))
+        end
+      end
+
+      class Mock
+        def set_load_balancer_policies_for_backend_server(lb_name, instance_port, policy_names)
+          if load_balancer = self.data[:load_balancers][lb_name]
+            # Ensure policies exist
+            policy_names.each do |policy_name|
+              unless load_balancer['Policies']['Proper'].find { |p| p['PolicyName'] == policy_name }
+                raise Fog::AWS::ELB::PolicyNotFound, "There is no policy with name #{policy_name} for load balancer #{lb_name}"
+              end
+            end
+
+            # Update backend policies:
+            description = load_balancer['BackendServerDescriptionsRemote'].find{|d| d["InstancePort"] == instance_port } || {}
+            description["InstancePort"] = instance_port
+            description["PolicyNames"] = policy_names
+            load_balancer['BackendServerDescriptionsRemote'].delete_if{|d| d["InstancePort"] == instance_port }
+            load_balancer['BackendServerDescriptionsRemote'] << description
+
+            Excon::Response.new.tap do |response|
+              response.status = 200
+              response.body = {
+                'ResponseMetadata' => {
+                  'RequestId' => Fog::AWS::Mock.request_id
+                }
+              }
+            end
+          else
+            raise Fog::AWS::ELB::NotFound
+          end
+        end
+      end
+    end
+  end
+end