fog-aws 1.4.1 → 3.27.0

data/lib/fog/aws/requests/dns/list_resource_record_sets.rb

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class AWS
+  module AWS
+    class DNS
       class Real
         require 'fog/aws/parsers/dns/list_resource_record_sets'
 
@@ -51,7 +51,7 @@ module Fog
             :expects => 200,
             :idempotent => true,
             :method  => 'GET',
-            :parser  => Fog::Parsers::DNS::AWS::ListResourceRecordSets.new,
+            :parser  => Fog::Parsers::AWS::DNS::ListResourceRecordSets.new,
             :path    => "hostedzone/#{zone_id}/rrset",
             :query   => parameters
           })
@@ -64,7 +64,7 @@ module Fog
             tmp_records.push(record) if !record[:name].nil? && ( name.nil? || record[:name].gsub(zone[:name],"") >= name)
             record.each do |key,subr|
               if subr.is_a?(Hash) && key.is_a?(String) &&
-                key.start_with?(Fog::DNS::AWS::Mock::SET_PREFIX)
+                key.start_with?(Fog::AWS::DNS::Mock::SET_PREFIX)
                 if name.nil?
                   tmp_records.append(subr)
                 else
@@ -81,7 +81,7 @@ module Fog
           response = Excon::Response.new
 
           zone = self.data[:zones][zone_id] ||
-            raise(Fog::DNS::AWS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist."))
+            raise(Fog::AWS::DNS::NotFound.new("NoSuchHostedZone => A hosted zone with the specified hosted zone ID does not exist."))
 
           records = if options[:type]
                       records_type = zone[:records][options[:type]]

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

@@ -7,15 +7,15 @@ module Fog
         #
         # ==== Parameters
         # * 'table_name'<~String> - name of table for item
-        # * 'key'<~Hash> - list of elements to be updated and their value
+        # * 'key'<~Hash> - list of Key attributes
         #   {
         #     "ForumName": {"S": "Amazon DynamoDB"},
         #     "Subject": {"S": "Maximum number of items?"}
         #   }
         #
         # * 'options'<~Hash>:
-        #   * 'KeyConditionExpression'<~String> - the condition elements need to match
-        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the key condition expression
+        #   * 'UpdateExpression'<~String> - the expression that will update the item
+        #   * 'ExpressionAttributeValues'<~Hash> - values to be used in the update expression
         #   * 'ReturnValues'<~String> - data to return in %w{ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD}, defaults to NONE
         #
         # ==== Returns
@@ -29,13 +29,14 @@ module Fog
           if deprecated_attribute_updates
             raise DeprecatedAttributeUpdates, "The `20111205` DynamoDB API is deprecated. You need to use `ExpressionAttributeValues` instead of `AttributeUpdates`."
             attribute_updates = options
-            options = deprecated_attribute_updates
+            options = deprecated_attribute_updates.merge(
+              'AttributeUpdates'  => attribute_updates,
+            )
           end
 
           body = {
             'Key'               => key,
             'TableName'         => table_name,
-            'AttributeUpdates'  => attribute_updates,
           }.merge(options)
 
           request(

data/lib/fog/aws/requests/ecs/list_task_definitions.rb

@@ -13,7 +13,7 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
-        #     * 'TaskDefinitionArns' <~Array> - list of task definition Amazon Resource Name (ARN) entries for the ListTaskDefintions request.
+        #     * 'TaskDefinitionArns' <~Array> - list of task definition Amazon Resource Name (ARN) entries for the ListTaskDefinitions request.
         #     * 'NextToken' <~String> - nextToken value to include in a future ListTaskDefinitions request
         def list_task_definitions(params={})
           request({

data/lib/fog/aws/requests/efs/create_file_system.rb

@@ -7,17 +7,27 @@ module Fog
         # ==== Parameters
         # * CreationToken <~String> - String of up to 64 ASCII characters. Amazon EFS uses this to ensure idempotent creation.
         # * PerformanceMode <~String> - (Optional) The PerformanceMode of the file system. We recommend generalPurpose performance mode for most file systems. File systems using the maxIO performance mode can scale to higher levels of aggregate throughput and operations per second with a tradeoff of slightly higher latencies for most file operations. This can't be changed after the file system has been created.
+        # * Encrypted <~Boolean> - (Optional) A Boolean value that, if true, creates an encrypted file system. When creating an encrypted file system, you have the option of specifying a CreateFileSystem:KmsKeyId for an existing AWS Key Management Service (AWS KMS) customer master key (CMK). If you don't specify a CMK, then the default CMK for Amazon EFS, /aws/elasticfilesystem, is used to protect the encrypted file system. 
+        # * KmsKeyId <~String> - (Optional) The ID of the AWS KMS CMK to be used to protect the encrypted file system. This parameter is only required if you want to use a non-default CMK. If this parameter is not specified, the default CMK for Amazon EFS is used. This ID can be in one of the following formats:
+        #   - Key ID - A unique identifier of the key, for example, 1234abcd-12ab-34cd-56ef-1234567890ab.
+        #   - ARN - An Amazon Resource Name (ARN) for the key, for example, arn:aws:kms:us-west-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab.
+        #   - Key alias - A previously created display name for a key. For example, alias/projectKey1.
+        #   - Key alias ARN - An ARN for a key alias, for example, arn:aws:kms:us-west-2:444455556666:alias/projectKey1.
+        #   If KmsKeyId is specified, the CreateFileSystem:Encrypted parameter must be set to true.
         # ==== Returns
         # * response<~Excon::Response>
         #   * body<~Hash>
         def create_file_system(creation_token, options={})
-          request({
+          params = {
             :path             => "file-systems",
             :method           => 'POST',
             :expects          => 201,
             'CreationToken'   => creation_token,
-            'PerformanceMode' => options[:peformance_mode] || 'generalPurpose'
-          })
+            'PerformanceMode' => options[:performance_mode] || 'generalPurpose',
+            'Encrypted'       => options[:encrypted] || false
+          }
+          params[:kms_key_id] = options[:kms_key_id] if options.key?(:kms_key_id)
+          request(params)
         end
       end
 
@@ -30,6 +40,7 @@ module Fog
             "OwnerId"              => Fog::AWS::Mock.owner_id,
             "CreationToken"        => creation_token,
             "PerformanceMode"      => options[:performance_mode] || "generalPurpose",
+            "Encrypted"            => options[:encrypted] || false,
             "FileSystemId"         => id,
             "CreationTime"         => Time.now.to_i.to_f,
             "LifeCycleState"       => "creating",
@@ -39,6 +50,7 @@ module Fog
               "Timestamp" => Time.now.to_i.to_f
             }
           }
+          file_system[:kms_key_id] = options[:kms_key_id] if options.key?(:kms_key_id)
 
           self.data[:file_systems][id] = file_system
           response.body = file_system

data/lib/fog/aws/requests/efs/create_mount_target.rb

@@ -25,8 +25,10 @@ module Fog
       class Mock
         def create_mount_target(file_system_id, subnet_id, options={})
           response               = Excon::Response.new
-          default_security_group = mock_compute.data[:security_groups]['default']
-          security_groups        = options["SecurityGroups"] || [default_security_group['groupId']]
+          default_security_group = mock_compute.data[:security_groups].find do |_, sg|
+            sg['groupDescription'] == 'default_elb security group'
+          end
+          security_groups        = options["SecurityGroups"] || [default_security_group.first]
 
           unless file_system = self.data[:file_systems][file_system_id]
             raise Fog::AWS::EFS::NotFound.new("invalid file system ID: #{file_system_id}")
@@ -41,8 +43,10 @@ module Fog
             raise Fog::AWS::EFS::InvalidSubnet.new("invalid subnet ID: #{subnet_id}")
           end
 
-          security_groups.each do |sg|
-            raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{sg}") unless mock_compute.data[:security_groups].values.detect { |sgd| sgd["groupId"] == sg }
+          security_groups.each do |group_id|
+            unless mock_compute.data[:security_groups][group_id]
+              raise Fog::AWS::EFS::NotFound.new("invalid security group ID: #{group_id}")
+            end
           end
 
           id = "fsmt-#{Fog::Mock.random_letters(8)}"

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

@@ -34,7 +34,7 @@ module Fog
           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")
+              raise Fog::AWS::Elasticache::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is already defined")
             end
             sec_group['EC2SecurityGroups'] << opts.merge({'Status' => 'authorizing'})
 

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

@@ -19,7 +19,7 @@ module Fog
         #   * :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_availability_zone <~String>
         #   * :preferred_maintenance_window <~String>
         #   * :cache_subnet_group_name <~String>
         #   * :s3_snapshot_location <~String> - Amazon resource location for snapshot
@@ -39,7 +39,7 @@ module Fog
             'EngineVersion'               => options[:engine_version],
             'NotificationTopicArn'        => options[:notification_topic_arn],
             'Port'                        => options[:port],
-            'PreferredAvailabilityZone'   => options[:preferred_availablility_zone],
+            'PreferredAvailabilityZone'   => options[:preferred_availability_zone],
             'PreferredMaintenanceWindow'  => options[:preferred_maintenance_window],
             :parser => Fog::Parsers::AWS::Elasticache::SingleCacheCluster.new
           }

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

@@ -24,7 +24,7 @@ module Fog
       end
 
       class Mock
-        def describe_engine_defalut_parameters(options = {})
+        def describe_engine_default_parameters(options = {})
           Fog::Mock.not_implemented
         end
       end

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

@@ -80,7 +80,7 @@ module Fog
                    elsif subnet_ids.any?
                      # using Hash here for Rubt 1.8.7 support.
                      Hash[
-                       Fog::Compute::AWS::Mock.data.select do |_, region_data|
+                       Fog::AWS::Compute::Mock.data.select do |_, region_data|
                          region_data[@aws_access_key_id][:subnets].any? do |region_subnets|
                            subnet_ids.include? region_subnets['subnetId']
                          end
@@ -89,8 +89,8 @@ module Fog
                    else
                      'us-east-1'
                    end
-          supported_platforms = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
-          subnets = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
+          supported_platforms = Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:account_attributes].find { |h| h["attributeName"] == "supported-platforms" }["values"]
+          subnets = Fog::AWS::Compute::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")
@@ -109,55 +109,24 @@ module Fog
 
           security_group = case elb_location
                            when 'EC2-Classic'
-                             Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups]['amazon-elb-sg']
+                             Fog::AWS::Compute::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
+                             compute = Fog::AWS::Compute::new(:aws_access_key_id => @aws_access_key_id, :aws_secret_access_key => @aws_secret_access_key)
 
-                             default_sg = Fog::Compute::AWS::Mock.data[region][@aws_access_key_id][:security_groups].values.find { |sg|
+                             vpc = compute.vpcs.all.first ||
+                               compute.vpcs.create('cidr_block' => '10.0.0.0/24')
+
+                             Fog::AWS::Compute::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|
+
+                             Fog::AWS::Compute::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] = {}

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

@@ -51,34 +51,37 @@ module Fog
 
       class Mock
         def create_load_balancer_listeners(lb_name, listeners)
-          if load_balancer = self.data[:load_balancers][lb_name]
-            response = Excon::Response.new
+          load_balancer = data[:load_balancers][lb_name]
+          raise Fog::AWS::ELB::NotFound unless load_balancer
+          response = Excon::Response.new
 
-            certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map {|n, c| c['Arn'] }
+          certificate_ids = Fog::AWS::IAM::Mock.data[@aws_access_key_id][:server_certificates].map { |_n, c| c['Arn'] }
 
-            listeners.each do |listener|
-              if listener['SSLCertificateId'] and !certificate_ids.include? listener['SSLCertificateId']
-                raise Fog::AWS::IAM::NotFound.new('CertificateNotFound')
-              end
+          listeners.each do |listener|
+            if listener['SSLCertificateId'] && !certificate_ids.include?(listener['SSLCertificateId'])
+              raise Fog::AWS::IAM::NotFound, 'CertificateNotFound'
+            end
 
-              if (%w( HTTP HTTPS).include?(listener['Protocol']) && !%w( HTTP HTTPS ).include?(listener['InstanceProtocol'])) ||
-                  (%w( TCP SSL).include?(listener['Protocol']) && !%w( TCP SSL ).include?(listener['InstanceProtocol']))
-                raise Fog::AWS::ELB::ValidationError
-              end if listener['Protocol'] && listener['InstanceProtocol']
-              load_balancer['ListenerDescriptions'] << {'Listener' => listener, 'PolicyNames' => []}
+            if listener['Protocol'] && listener['InstanceProtocol']
+              if (
+                  %w[HTTP HTTPS].include?(listener['Protocol']) && !%w[HTTP HTTPS].include?(listener['InstanceProtocol'])
+              ) || (
+                %w[TCP SSL].include?(listener['Protocol']) && !%w[TCP SSL].include?(listener['InstanceProtocol'])
+              )
+              raise Fog::AWS::ELB::ValidationError
+              end
             end
+            load_balancer['ListenerDescriptions'] << { 'Listener' => listener, 'PolicyNames' => [] }
+          end
 
-            response.status = 200
-            response.body = {
-              'ResponseMetadata' => {
-                'RequestId' => Fog::AWS::Mock.request_id
-              }
+          response.status = 200
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
             }
+          }
 
-            response
-          else
-            raise Fog::AWS::ELB::NotFound
-          end
+          response
         end
       end
     end

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

@@ -4,7 +4,7 @@ module Fog
       class Real
         require 'fog/aws/parsers/elb/empty'
 
-        # Delet Elastic Load Balancer Listeners
+        # Delete Elastic Load Balancer Listeners
         #
         # ==== Parameters
         # * lb_name<~String> - Name for the new ELB -- must be unique

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

@@ -35,7 +35,7 @@ module Fog
           raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
           instance_ids = [*instance_ids]
           instance_ids.each do |instance|
-            raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
+            raise Fog::AWS::ELB::InvalidInstance unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][instance]
           end
 
           response = Excon::Response.new

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

@@ -38,7 +38,7 @@ module Fog
           instance_ids = [*instance_ids]
           instance_ids = load_balancer['Instances'].map { |i| i['InstanceId'] } unless instance_ids.any?
           data = instance_ids.map do |id|
-            unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][id]
+            unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][id]
               raise Fog::AWS::ELB::InvalidInstance
             end
 

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

@@ -24,7 +24,7 @@ module Fog
         #   request({
         #     'Action'    => 'DescribeTags',
         #     :idempotent => true,
-        #     :parser     => Fog::Parsers::Compute::AWS::DescribeTags.new
+        #     :parser     => Fog::Parsers::AWS::Compute::DescribeTags.new
         #   }.merge!(params))
         # end
 

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

@@ -35,7 +35,7 @@ module Fog
           raise Fog::AWS::ELB::NotFound unless load_balancer = self.data[:load_balancers][lb_name]
           instance_ids = [*instance_ids]
           instances = instance_ids.map do |instance|
-            raise Fog::AWS::ELB::InvalidInstance unless Fog::Compute::AWS::Mock.data[@region][@aws_access_key_id][:instances][instance]
+            raise Fog::AWS::ELB::InvalidInstance unless Fog::AWS::Compute::Mock.data[@region][@aws_access_key_id][:instances][instance]
             {'InstanceId' => instance}
           end
 

data/lib/fog/aws/requests/elbv2/add_tags.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/empty'
+
+        # adds tags to a load balancer instance
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_AddTags.html
+        # ==== Parameters
+        # * resource_arn <~String> - The Amazon Resource Name (ARN) of the resource
+        # * tags <~Hash> A Hash of (String) key-value pairs
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def add_tags(resource_arn, tags)
+          keys    = tags.keys.sort
+          values  = keys.map {|key| tags[key]}
+          request({
+              'Action'                     => 'AddTags',
+              'ResourceArns.member.1'      => resource_arn,
+              :parser                      => Fog::Parsers::AWS::ELBV2::Empty.new,
+            }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys))
+             .merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
+        end
+
+      end
+
+      class Mock
+        def add_tags(resource_arn, tags)
+          response = Excon::Response.new
+          if self.data[:load_balancers_v2][resource_arn]
+            self.data[:tags][resource_arn].merge! tags
+            response.status = 200
+            response.body = {
+              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+            }
+            response
+          else
+            raise Fog::AWS::ELBV2::NotFound.new("Elastic load balancer #{resource_arn} not found")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/create_load_balancer'
+
+        # Create a new Elastic Load Balancer
+        #
+        # ==== Parameters
+        # * name<~String> - The name of the load balancer.
+        #                   This name must be unique per region per account, can have a maximum of 32 characters, must contain only alphanumeric characters or hyphens,
+        #                   must not begin or end with a hyphen, and must not begin with "internal-".
+        #                 - Required: Yes
+        # * options<~Hash>:
+        #   * ip_address_type<~String> - [Application Load Balancers] The type of IP addresses used by the subnets for your load balancer.
+        #                                The possible values are ipv4 (for IPv4 addresses) and dualstack (for IPv4 and IPv6 addresses).
+        #                                Internal load balancers must use ipv4.
+        #                              - Required: No
+        #   * scheme<~String> - The default is an Internet-facing load balancer. Valid Values: internet-facing | internal
+        #                     - Required: No
+        #   * security_groups<~Array> - The IDs of the security groups for the load balancer.
+        #                             - Required: No
+        #   * subnet_mappings<~Array> - The IDs of the public subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings.
+        #                             - [Application Load Balancers] You must specify subnets from at least two Availability Zones.
+        #                               You cannot specify Elastic IP addresses for your subnets.
+        #                             - [Network Load Balancers] You can specify subnets from one or more Availability Zones.
+        #                               You can specify one Elastic IP address per subnet if you need static IP addresses for your internet-facing load balancer.
+        #                               For internal load balancers, you can specify one private IP address per subnet from the IPv4 range of the subnet.
+        #                             - Required: No
+        #   * subnets<~Array> - The IDs of the public subnets. You can specify only one subnet per Availability Zone. You must specify either subnets or subnet mappings.
+        #                     - [Application Load Balancers] You must specify subnets from at least two Availability Zones.
+        #                     - [Network Load Balancers] You can specify subnets from one or more Availability Zones.
+        #                     - Required: No
+        #   * tags<~Hash> - One or more tags to assign to the load balancer.
+        #                 - Required: No
+        #   * type<~String> - The type of load balancer. The default is application. Valid Values: application | network
+        #                   - Required: No
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'CreateLoadBalancerResult'<~Hash>:
+        #       * 'LoadBalancers'<~Array>
+        #         * 'AvailabilityZones'<~Array>:
+        #           * 'SubnetId'<~String> - ID of the subnet
+        #           * 'ZoneName'<~String> - Name of the Availability Zone
+        #           * 'LoadBalancerAddresses'<~Array>:
+        #             * 'IpAddress'<~String> - IP address
+        #             * 'AllocationId'<~String> - ID of the AWS allocation
+        #         * '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
+        #         * 'LoadBalancerName'<~String> - name of load balancer
+        #         * 'SecurityGroups'<~Array> - array of security group id
+        def create_load_balancer(name, options = {})
+          params = {}
+          params.merge!(Fog::AWS.indexed_param('Subnets.member.%d', options[:subnets]))
+          params.merge!(Fog::AWS.indexed_param('SecurityGroups.member.%d', options[:security_groups]))
+          params.merge!(Fog::AWS.serialize_keys('Scheme', options[:scheme]))
+          params.merge!(Fog::AWS.serialize_keys('Type', options[:type]))
+          params.merge!(Fog::AWS.serialize_keys('IpAddressType', options[:ip_address_type]))
+
+
+          unless options[:tags].nil?
+            tag_keys   = options[:tags].keys.sort
+            tag_values = tag_keys.map { |key| options[:tags][key] }
+            params.merge!(Fog::AWS.indexed_param('Tags.member.%d.Key', tag_keys))
+            params.merge!(Fog::AWS.indexed_param('Tags.member.%d.Value', tag_values))
+          end
+
+          unless options[:subnet_mappings].nil?
+            subnet_ids = []
+            allocation_ids = []
+            private_ipv4_address = []
+            options[:subnet_mappings].each do |subnet_mapping|
+              subnet_ids.push(subnet_mapping[:subnet_id])
+              allocation_ids.push(subnet_mapping[:allocation_id])
+              private_ipv4_address.push(subnet_mapping[:private_ipv4_address])
+            end
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.SubnetId', subnet_ids))
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.AllocationId', allocation_ids))
+            params.merge!(Fog::AWS.indexed_param('SubnetMappings.member.%d.PrivateIPv4Address', private_ipv4_address))
+          end
+
+
+          request({
+            'Action'           => 'CreateLoadBalancer',
+            'Name' => name,
+            :parser            => Fog::Parsers::AWS::ELBV2::CreateLoadBalancer.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        def create_load_balancer(name, options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          raise Fog::AWS::ELBV2::IdentifierTaken if self.data[:load_balancers_v2].key? name
+
+          dns_name = Fog::AWS::ELBV2::Mock.dns_name(name, @region)
+          type = options[:type] || 'application'
+          load_balancer_arn = Fog::AWS::Mock.arn('elasticloadbalancing', self.data[:owner_id], "loadbalancer/#{type[0..2]}/#{name}/#{Fog::AWS::Mock.key_id}")
+
+          subnet_ids = options[:subnets] || []
+          region = if subnet_ids.any?
+                     # using Hash here for Rubt 1.8.7 support.
+                     Hash[
+                       Fog::AWS::Compute::Mock.data.select do |_, region_data|
+                         unless region_data[@aws_access_key_id].nil?
+                           region_data[@aws_access_key_id][:subnets].any? do |region_subnets|
+                             subnet_ids.include? region_subnets['subnetId']
+                           end
+                         end
+                       end
+                     ].keys[0]
+                   else
+                     'us-east-1'
+                   end
+
+          subnets = Fog::AWS::Compute::Mock.data[region][@aws_access_key_id][:subnets].select {|e| subnet_ids.include?(e["subnetId"]) }
+          availability_zones = subnets.map do |subnet|
+            { "LoadBalancerAddresses"=>[], "SubnetId"=>subnet["subnetId"], "ZoneName"=>subnet["availabilityZone"]}
+          end
+          vpc_id = subnets.first['vpcId']
+
+          self.data[:tags] ||= {}
+          self.data[:tags][load_balancer_arn] = options[:tags] || {}
+
+          load_balancer = {
+            'AvailabilityZones' => availability_zones || [],
+            'Scheme' => options[:scheme] || 'internet-facing',
+            'SecurityGroups' => options[:security_groups] || [],
+            'CanonicalHostedZoneId' => '',
+            'CreatedTime' => Time.now,
+            'DNSName' => dns_name,
+            'VpcId' => vpc_id,
+            'Type' => type,
+            'State' => {'Code' => 'provisioning'},
+            'LoadBalancerArn' => load_balancer_arn,
+            'LoadBalancerName' => name
+          }
+          self.data[:load_balancers_v2][load_balancer_arn] = load_balancer
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'CreateLoadBalancerResult' => {
+              'LoadBalancers' => [load_balancer]
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elbv2/describe_listeners.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_listeners'
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * 'LoadBalancerArn'<~String> - The Amazon Resource Name (ARN) of the load balancer
+        # * options<~Hash>
+        #   * '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
+        #     * 'DescribeListenersResult'<~Hash>:
+        #       * 'Listeners'<~Array>
+        #         * 'LoadBalancerArn'<~String> - The Amazon Resource Name (ARN) of the load balancer
+        #         * 'Protocol'<~String> - The protocol for connections from clients to the load balancer
+        #         * 'Port'<~String> - The port on which the load balancer is listening
+        #         * 'DefaultActions'<~Array> - The default actions for the listener
+        #           * 'Type'<~String> - The type of action
+        #           * 'TargetGroupArn'<~String> - The Amazon Resource Name (ARN) of the target group. Specify only when Type is forward
+        #       * 'NextMarker'<~String> - Marker to specify for next page
+        def describe_listeners(load_balancer_arn, options = {})
+          request({
+            'Action'  => 'DescribeListeners',
+            'LoadBalancerArn' => load_balancer_arn,
+            :parser   => Fog::Parsers::AWS::ELBV2::DescribeListeners.new
+          }.merge!(options))
+        end
+      end
+    end
+  end
+end