fog-aws 3.5.2 → 3.6.6

data/lib/fog/aws/parsers/elbv2/describe_load_balancers.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Parsers
+    module AWS
+      module ELBV2
+        class DescribeLoadBalancers < Fog::Parsers::Base
+          def reset
+            reset_load_balancer
+            reset_availability_zone
+            @load_balancer_addresses = {}
+            @state = {}
+            @results = { 'LoadBalancers' => [] }
+            @response = { 'DescribeLoadBalancersResult' => {}, 'ResponseMetadata' => {} }
+          end
+
+          def reset_load_balancer
+            @load_balancer = { 'SecurityGroups' => [], 'AvailabilityZones' => [] }
+          end
+
+          def reset_availability_zone
+            @availability_zone = { 'LoadBalancerAddresses' => [] }
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'AvailabilityZones'
+              @in_availability_zones = true
+            when 'LoadBalancerAddresses'
+              @in_load_balancer_addresses = true
+            when 'SecurityGroups'
+              @in_security_groups = true
+            when 'State'
+              @in_state = true
+            end
+          end
+
+          def end_element(name)
+            case name
+            when 'member'
+              if @in_availability_zones && @in_load_balancer_addresses
+                @availability_zone['LoadBalancerAddresses'] << @load_balancer_addresses
+              elsif @in_availability_zones
+                @load_balancer['AvailabilityZones'] << @availability_zone
+                reset_availability_zone
+              elsif @in_security_groups
+                @load_balancer['SecurityGroups'] << value
+              else
+                @results['LoadBalancers'] << @load_balancer
+                reset_load_balancer
+              end
+            when 'SubnetId', 'ZoneName'
+              @availability_zone[name] = value
+            when 'IpAddress', 'AllocationId'
+              @load_balancer_addresses[name] = value
+
+            when 'CanonicalHostedZoneName', 'CanonicalHostedZoneNameID', 'LoadBalancerName', 'DNSName', 'Scheme', 'Type',
+                 'LoadBalancerArn', 'IpAddressType', 'CanonicalHostedZoneId', 'VpcId'
+              @load_balancer[name] = value
+            when 'CreatedTime'
+              @load_balancer[name] = Time.parse(value)
+
+            when 'LoadBalancerAddresses'
+              @in_load_balancer_addresses = false
+            when 'AvailabilityZones'
+              @in_availability_zones = false
+            when 'SecurityGroups'
+              @in_security_groups = false
+            when 'State'
+              @in_state = false
+              @load_balancer[name] = @state
+              @state = {}
+            when 'Code'
+              @state[name] = value
+
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = value
+
+            when 'NextMarker'
+              @results['NextMarker'] = value
+            when 'DescribeLoadBalancersResponse'
+              @response['DescribeLoadBalancersResult'] = @results
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/elbv2/describe_tags.rb

@@ -0,0 +1,53 @@
+module Fog
+  module Parsers
+    module AWS
+      module ELBV2
+        class DescribeTags < Fog::Parsers::Base
+          def reset
+            @this_key   = nil
+            @this_value = nil
+            @tags       = Hash.new
+            @response   = { 'DescribeTagsResult' => { 'TagDescriptions' => [] }, 'ResponseMetadata' => {} }
+            @in_tags = false
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+              when 'member'
+                unless @in_tags
+                  @resource_arn = nil
+                  @tags = {}
+                end
+              when 'Tags'
+                @in_tags = true
+            end
+          end
+
+          def end_element(name)
+            super
+            case name
+              when 'member'
+                if @in_tags
+                  @tags[@this_key] = @this_value
+                  @this_key, @this_value = nil, nil
+                else
+                  @response['DescribeTagsResult']['TagDescriptions'] << { 'Tags' => @tags, 'ResourceArn' => @resource_arn }
+                end
+              when 'Key'
+                @this_key = value
+              when 'Value'
+                @this_value = value
+              when 'ResourceArn'
+                @resource_arn = value
+              when 'RequestId'
+                @response['ResponseMetadata'][name] = value
+              when 'Tags'
+                @in_tags = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/elbv2/empty.rb

@@ -0,0 +1,10 @@
+module Fog
+  module Parsers
+    module AWS
+      module ELBV2
+        class Empty < ELB::Empty
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/storage/get_object_tagging.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Parsers
+    module AWS
+      module Storage
+        class GetObjectTagging < Fog::Parsers::Base
+          def reset
+            @in_tag = {}
+            @response = {'ObjectTagging' => {}}
+          end
+
+          def start_element(name, *args)
+            super
+            if name == 'Tag'
+              @in_tag = {}
+            end
+          end
+
+          def end_element(name)
+            case name
+            when 'Tag'
+              @response['ObjectTagging'].merge!(@in_tag)
+              @in_tag = {}
+            when 'Key'
+              @in_tag[value] = nil
+            when 'Value'
+              @in_tag = {@in_tag.keys.first => value}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/sts/assume_role_with_web_identity.rb

@@ -2,7 +2,7 @@ module Fog
   module Parsers
     module AWS
       module STS
-        class AssumeRoleWithWithWebIdentity < Fog::Parsers::Base
+        class AssumeRoleWithWebIdentity < Fog::Parsers::Base
           def reset
             @response = {}
           end

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

@@ -11,7 +11,6 @@ module Fog
         # * options<~Hash>:
         #   * InstanceTenancy<~String> - The allowed tenancy of instances launched into the VPC. A value of default
         #     means instances can be launched with any tenancy; a value of dedicated means instances must be launched with tenancy as dedicated.
-        #     please not that the documentation is incorrect instanceTenancy will not work while InstanceTenancy will
         #
         # === Returns
         # * response<~Excon::Response>:
@@ -54,7 +53,8 @@ module Fog
                 'classicLinkEnabled'          => false,
                 'classicLinkDnsSupport'       => false,
                 'cidrBlockAssociationSet'     => [{ 'cidrBlock' => cidrBlock, 'state' => 'associated', 'associationId' => "vpc-cidr-assoc-#{vpc_id}" }],
-                'ipv6CidrBlockAssociationSet' => []
+                'ipv6CidrBlockAssociationSet' => [],
+                'instanceTenancy'             => options['InstanceTenancy'] || 'default'
               }
               self.data[:vpcs].push(vpc)
 

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

@@ -30,6 +30,8 @@ module Fog
         #     * 'Ebs.Encrypted'<~Boolean> - specifies whether or not the volume is to be encrypted unless snapshot is specified
         #     * 'Ebs.VolumeType'<~String> - Type of EBS volue. Valid options in ['standard', 'io1'] default is 'standard'.
         #     * 'Ebs.Iops'<~String> - The number of I/O operations per second (IOPS) that the volume supports. Required when VolumeType is 'io1'
+        #   * 'HibernationOptions'<~Array>: array of hashes
+        #     * 'Configured'<~Boolean> - specifies whether or not the instance is configued for hibernation.  This parameter is valid only if the instance meets the hibernation prerequisites.  
         #   * 'NetworkInterfaces'<~Array>: array of hashes
         #     * 'NetworkInterfaceId'<~String> - An existing interface to attach to a single instance
         #     * 'DeviceIndex'<~String> - The device index. Applies both to attaching an existing network interface and creating a network interface
@@ -75,6 +77,8 @@ module Fog
         #           * 'deviceName'<~String> - specifies how volume is exposed to instance
         #           * 'status'<~String> - status of attached volume
         #           * 'volumeId'<~String> - Id of attached volume
+        #         * 'hibernationOptions'<~Array>
+        #           * 'configured'<~Boolean> - whether or not the instance is enabled for hibernation               
         #         * 'dnsName'<~String> - public dns name, blank until instance is running
         #         * 'imageId'<~String> - image id of ami used to launch instance
         #         * 'instanceId'<~String> - id of the instance
@@ -111,6 +115,13 @@ module Fog
               end
             end
           end
+          if hibernation_options = options.delete('HibernationOptions')
+            hibernation_options.each_with_index do |mapping, index|
+              for key, value in mapping
+                options.merge!({ format("HibernationOptions.%d.#{key}", index) => value })
+              end
+            end
+          end
           if security_groups = options.delete('SecurityGroup')
             options.merge!(Fog::AWS.indexed_param('SecurityGroup', [*security_groups]))
           end
@@ -182,6 +193,14 @@ module Fog
               }
             end
 
+	    hibernation_options = (options['HibernationOptions'] || []).reduce([]) do |mapping, device|
+              configure = device.fetch("Configure", true)
+
+              mapping << {
+                "Configure" => configure,
+              }
+            end
+
             if options['SubnetId']
               if options['PrivateIpAddress']
                 ni_options = {'PrivateIpAddress' => options['PrivateIpAddress']}
@@ -221,6 +240,7 @@ module Fog
               'associatePublicIP'     => options['associatePublicIP'] || false,
               'architecture'          => 'i386',
               'blockDeviceMapping'    => block_device_mapping,
+              'hibernationOptions'    => hibernation_options,
               'networkInterfaces'     => network_interfaces,
               'clientToken'           => options['clientToken'],
               'dnsName'               => nil,

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

@@ -16,9 +16,17 @@ module Fog
         #     * TODO: fill in the blanks
         #
         # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-StopInstances.html]
-        def stop_instances(instance_id, force = false)
+        def stop_instances(instance_id, options = {})
           params = Fog::AWS.indexed_param('InstanceId', instance_id)
-          params.merge!('Force' => 'true') if force
+          unless options.is_a?(Hash)
+            Fog::Logger.warning("stop_instances with #{options.class} param is deprecated, use stop_instances('force' => boolean) instead [light_black](#{caller.first})[/]")
+            options = {'force' => options}
+          end
+          params.merge!('Force' => 'true') if options['force']
+          if options['hibernate']
+            params.merge!('Hibernate' => 'true')
+            params.merge!('Force' => 'false')
+          end
           request({
             'Action'    => 'StopInstances',
             :idempotent => true,
@@ -28,7 +36,7 @@ module Fog
       end
 
       class Mock
-        def stop_instances(instance_id, force = false)
+        def stop_instances(instance_id, options = {})
           instance_ids = Array(instance_id)
 
           instance_set = self.data[:instances].values

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