fog-aws 3.5.2 → 3.19.0

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
@@ -42,6 +44,11 @@ module Fog
         #     * 'PrivateIpAddresses.Primary'<~Bool> - Indicates whether the private IP address is the primary private IP address.
         #     * 'SecondaryPrivateIpAddressCount'<~Bool> - The number of private IP addresses to assign to the network interface.
         #     * 'AssociatePublicIpAddress'<~String> - Indicates whether to assign a public IP address to an instance in a VPC. The public IP address is assigned to a specific network interface
+        #   * 'TagSpecifications'<~Array>: array of hashes
+        #     * 'ResourceType'<~String> - Type of resource to apply tags on, e.g: instance or volume
+        #     * 'Tags'<~Array> - List of hashs reprensenting tag to be set
+        #       * 'Key'<~String> - Tag name
+        #       * 'Value'<~String> - Tag value
         #   * 'ClientToken'<~String> - unique case-sensitive token for ensuring idempotency
         #   * 'DisableApiTermination'<~Boolean> - specifies whether or not to allow termination of the instance from the api
         #   * 'SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances (not supported for VPC)
@@ -75,6 +82,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 +120,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
@@ -133,6 +149,45 @@ module Fog
               end
             end
           end
+          if tag_specifications = options.delete('TagSpecifications')
+            # From https://docs.aws.amazon.com/sdk-for-ruby/v2/api/Aws/EC2/Client.html#run_instances-instance_method
+            # And https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html
+            # Discussed at https://github.com/fog/fog-aws/issues/603
+            #
+            # Example
+            #
+            # TagSpecifications: [
+            #     {
+            #       ResourceType: "instance",
+            #       Tags: [
+            #         {
+            #           Key: "Project",
+            #           Value: "MyProject",
+            #         },
+            #       ],
+            #     },
+            #     {
+            #       ResourceType: "volume",
+            #       Tags: [
+            #         {
+            #           Key: "Project",
+            #           Value: "MyProject",
+            #         },
+            #       ],
+            #     },
+            # ]
+            tag_specifications.each_with_index do |val, idx|
+              resource_type = val["ResourceType"]
+              tags = val["Tags"]
+              options["TagSpecification.#{idx}.ResourceType"] = resource_type
+              tags.each_with_index do |tag, tag_idx|
+                aws_tag_key = "TagSpecification.#{idx}.Tag.#{tag_idx}.Key"
+                aws_tag_value = "TagSpecification.#{idx}.Tag.#{tag_idx}.Value"
+                options[aws_tag_key] = tag["Key"]
+                options[aws_tag_value] = tag["Value"]
+              end
+            end
+          end
 
           idempotent = !(options['ClientToken'].nil? || options['ClientToken'].empty?)
 
@@ -182,6 +237,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 +284,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

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

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

@@ -0,0 +1,100 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_load_balancers'
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * options<~Hash>
+        #   * 'LoadBalancerNames'<~Array> - List of load balancer names to describe, defaults to all
+        #   * 'Marker'<String> - Indicates where to begin in your list of load balancers
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancersResult'<~Hash>:
+        #       * '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
+        #         * 'NextMarker'<~String> - Marker to specify for next page
+        def describe_load_balancers(options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
+            options = { 'LoadBalancerNames' => [options].flatten }
+          end
+
+          if names = options.delete('LoadBalancerNames')
+            options.update(Fog::AWS.indexed_param('LoadBalancerNames.member', [*names]))
+          end
+
+          request({
+            'Action'  => 'DescribeLoadBalancers',
+            :parser   => Fog::Parsers::AWS::ELBV2::DescribeLoadBalancers.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def describe_load_balancers(options = {})
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("describe_load_balancers with #{options.class} is deprecated, use all('LoadBalancerNames' => []) instead [light_black](#{caller.first})[/]")
+            options = { 'LoadBalancerNames' => [options].flatten }
+          end
+
+          lb_names = options['LoadBalancerNames'] || []
+
+          lb_names = [*lb_names]
+          load_balancers = if lb_names.any?
+            lb_names.map do |lb_name|
+              lb = self.data[:load_balancers_v2].find { |name, data| name == lb_name }
+              raise Fog::AWS::ELBV2::NotFound unless lb
+              lb[1].dup
+            end.compact
+          else
+            self.data[:load_balancers_v2].map { |lb, values| values.dup }
+          end
+
+          marker = options.fetch('Marker', 0).to_i
+          if load_balancers.count - marker > 400
+            next_marker = marker + 400
+            load_balancers = load_balancers[marker...next_marker]
+          else
+            next_marker = nil
+          end
+
+          response = Excon::Response.new
+          response.status = 200
+
+          response.body = {
+            'ResponseMetadata' => {
+              'RequestId' => Fog::AWS::Mock.request_id
+            },
+            'DescribeLoadBalancersResult' => {
+              'LoadBalancers' => load_balancers
+            }
+          }
+
+          if next_marker
+            response.body['DescribeLoadBalancersResult']['NextMarker'] = next_marker.to_s
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/describe_tags'
+
+        # returns a Hash of tags for a load balancer
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_DescribeTags.html
+        # ==== Parameters
+        # * resource_arns <~Array> - ARN(s) of the ELB instance whose tags are to be retrieved
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def describe_tags(resource_arns)
+          request({
+              'Action' => 'DescribeTags',
+              :parser  => Fog::Parsers::AWS::ELBV2::DescribeTags.new
+            }.merge!(Fog::AWS.indexed_param('ResourceArns.member.%d', [*resource_arns]))
+          )
+        end
+      end
+
+      class Mock
+        def describe_tags(resource_arns)
+          response = Excon::Response.new
+          resource_arns = [*resource_arns]
+
+          tag_describtions = resource_arns.map do |resource_arn|
+            if self.data[:load_balancers_v2][resource_arn]
+              {
+                "Tags"=>self.data[:tags][resource_arn],
+                "ResourceArn"=>resource_arn
+              }
+            else
+              raise Fog::AWS::ELBV2::NotFound.new("Elastic load balancer #{resource_arns} not found")
+            end
+          end
+
+          response.status = 200
+          response.body = {
+            "ResponseMetadata"=>{"RequestId"=> Fog::AWS::Mock.request_id },
+            "DescribeTagsResult"=>{"TagDescriptions"=> tag_describtions}
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class ELBV2
+      class Real
+        require 'fog/aws/parsers/elbv2/empty'
+
+        # removes tags from an elastic load balancer instance
+        # http://docs.aws.amazon.com/ElasticLoadBalancing/latest/APIReference/API_RemoveTags.html
+        # ==== Parameters
+        # * resource_arn <~String> - ARN of the ELB instance whose tags are to be retrieved
+        # * keys <~Array> A list of String keys for the tags to remove
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        def remove_tags(resource_arn, keys)
+          request(
+            { 'Action'                      => 'RemoveTags',
+              'ResourceArns.member.1'  => resource_arn,
+              :parser => Fog::Parsers::AWS::ELBV2::Empty.new,
+            }.merge(Fog::AWS.indexed_param('TagKeys.member.%d', keys))
+          )
+        end
+
+      end
+
+      class Mock
+
+        def remove_tags(resource_arn, keys)
+          response = Excon::Response.new
+          if self.data[:load_balancers_v2][resource_arn]
+            keys.each {|key| self.data[:tags][resource_arn].delete key}
+            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/rds/add_tags_to_resource.rb

@@ -12,28 +12,30 @@ module Fog
         #   * body<~Hash>:
         def add_tags_to_resource(rds_id, tags)
           keys    = tags.keys.sort
-          values  = keys.map {|key| tags[key]}
+          values  = keys.map { |key| tags[key] }
+          resource_name = "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}"
+          %w[us-gov-west-1 us-gov-east-1].include?(@region) ? resource_name.insert(7, '-us-gov') : resource_name
           request({
-              'Action'        => 'AddTagsToResource',
-              'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
-              :parser         => Fog::Parsers::AWS::RDS::Base.new,
-            }.merge(Fog::AWS.indexed_param('Tags.member.%d.Key', keys)).
-              merge(Fog::AWS.indexed_param('Tags.member.%d.Value', values)))
+            'Action' => 'AddTagsToResource',
+            'ResourceName' => resource_name,
+            :parser => Fog::Parsers::AWS::RDS::Base.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_to_resource(rds_id, tags)
           response = Excon::Response.new
-          if server = self.data[:servers][rds_id]
-            self.data[:tags][rds_id].merge! tags
+          if server = data[:servers][rds_id]
+            data[:tags][rds_id].merge! tags
             response.status = 200
             response.body = {
-              "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
+              'ResponseMetadata' => { 'RequestId' => Fog::AWS::Mock.request_id }
             }
             response
           else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+            raise Fog::AWS::RDS::NotFound, "DBInstance #{rds_id} not found"
           end
         end
       end

data/lib/fog/aws/requests/rds/list_tags_for_resource.rb

@@ -11,11 +11,14 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Hash>:
+
         def list_tags_for_resource(rds_id)
+          resource_name = "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}"
+          %w[us-gov-west-1 us-gov-east-1].include?(@region) ? resource_name.insert(7, '-us-gov') : resource_name
           request(
-            'Action'        => 'ListTagsForResource',
-            'ResourceName'  => "arn:aws:rds:#{@region}:#{owner_id}:db:#{rds_id}",
-            :parser         => Fog::Parsers::AWS::RDS::TagListParser.new
+            'Action' => 'ListTagsForResource',
+            'ResourceName' => resource_name,
+            :parser => Fog::Parsers::AWS::RDS::TagListParser.new
           )
         end
       end
@@ -23,15 +26,15 @@ module Fog
       class Mock
         def list_tags_for_resource(rds_id)
           response = Excon::Response.new
-          if server = self.data[:servers][rds_id]
+          if server = data[:servers][rds_id]
             response.status = 200
             response.body = {
-              "ListTagsForResourceResult" =>
-                {"TagList" =>  self.data[:tags][rds_id]}
+              'ListTagsForResourceResult' =>
+                { 'TagList' => data[:tags][rds_id] }
             }
             response
           else
-            raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
+            raise Fog::AWS::RDS::NotFound, "DBInstance #{rds_id} not found"
           end
         end
       end