fog 1.23.0 → 1.42.1

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

@@ -1,66 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Modifies the specified attribute of the specified VPC.
-        #
-        # ==== Parameters
-        # * vpc_id<~String> - The ID of the VPC.
-        # * options<~Hash>:
-        #   * enableDnsSupport<~Boolean> - Indicates whether DNS resolution is supported for the VPC. If this attribute is true, the Amazon DNS
-        #     server resolves DNS hostnames for your instances to their corresponding IP addresses; otherwise, it does not.
-        #   * enableDnsHostnames<~Boolean> - Indicates whether the instances launched in the VPC get DNS hostnames. If this attribute is true,
-        #     instances in the VPC get DNS hostnames; otherwise, they do not. You can only set enableDnsHostnames to true if you also set the
-        #     EnableDnsSupport attribute to true.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ModifyVpcAttribute.html]
-        def modify_vpc_attribute(vpc_id, options = {})
-          request({
-            'Action'             => 'ModifyVpcAttribute',
-            'VpcId'              => vpc_id,
-            :idempotent          => true,
-            :parser              => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def modify_vpc_attribute(vpc_id, options = {})
-          response = Excon::Response.new
-          if options.size == 0
-            raise Fog::Compute::AWS::Error.new("InvalidParameterCombination => No attributes specified.")
-          elsif options.size > 1
-            raise Fog::Compute::AWS::Error.new("InvalidParameterCombination =>  InvalidParameterCombination => Fields for multiple attribute types specified: #{options.keys.join(', ')}")
-          elsif vpc = self.data[:vpcs].find{ |v| v['vpcId'] == vpc_id }
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-
-            attribute = options.keys.first
-            case attribute
-            when 'EnableDnsSupport.Value'
-              vpc['enableDnsSupport'] = options[attribute]
-            when 'EnableDnsHostnames.Value'
-              vpc['enableDnsHostnames'] = options[attribute]
-            else
-              raise Fog::Compute::AWS::Error.new("Illegal attribute '#{attribute}' specified")
-            end
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The VPC '#{vpc_id}' does not exist.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/monitor_unmonitor_instances'
-
-        # Monitor specified instance
-        # http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-MonitorInstances.html
-        #
-        # ==== Parameters
-        # * instance_ids<~Array> - Arrays of instances Ids to monitor
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'instancesSet': http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-MonitorInstancesResponseSetItemType.html
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-MonitorInstances.html]
-        def monitor_instances(instance_ids)
-          params = Fog::AWS.indexed_param('InstanceId', instance_ids)
-          request({
-                          'Action' => 'MonitorInstances',
-                          :idempotent => true,
-                          :parser => Fog::Parsers::Compute::AWS::MonitorUnmonitorInstances.new
-                  }.merge!(params))
-        end
-      end
-
-      class Mock
-        def monitor_instances(instance_ids)
-          response        = Excon::Response.new
-          response.status = 200
-          [*instance_ids].each do |instance_id|
-            if instance = self.data[:instances][instance_id]
-              instance['monitoring']['state'] = 'enabled'
-            else
-              raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_ids}' does not exist")
-            end
-          end
-          instances_set = [*instance_ids].reduce([]) { |memo, id| memo << {'instanceId' => id, 'monitoring' => 'enabled'} }
-          response.body = {'requestId' => 'some_request_id', 'instancesSet' => instances_set}
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/purchase_reserved_instances_offering'
-
-        # Purchases a Reserved Instance for use with your account.
-        #
-        # ==== Parameters
-        # * reserved_instances_offering_id<~String> - ID of the Reserved Instance offering you want to purchase.
-        # * instance_count<~Integer> - The number of Reserved Instances to purchase.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'reservedInstancesId'<~String> - Id of the purchased reserved instances.
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-PurchaseReservedInstancesOffering.html]
-        def purchase_reserved_instances_offering(reserved_instances_offering_id, instance_count = 1)
-          request({
-            'Action'                      => 'PurchaseReservedInstancesOffering',
-            'ReservedInstancesOfferingId' => reserved_instances_offering_id,
-            'InstanceCount'               => instance_count,
-            :idempotent                   => true,
-            :parser                       => Fog::Parsers::Compute::AWS::PurchaseReservedInstancesOffering.new
-          })
-        end
-      end
-
-      class Mock
-        def purchase_reserved_instances_offering(reserved_instances_offering_id, instance_count = 1)
-          response = Excon::Response.new
-          response.status = 200
-
-          # Need to implement filters in the mock to find this there instead of here
-          # Also there's no information about what to do when the specified reserved_instances_offering_id doesn't exist
-          raise unless reserved_instance_offering = describe_reserved_instances_offerings.body["reservedInstancesOfferingsSet"].find { |offering| offering["reservedInstancesOfferingId"] == reserved_instances_offering_id }
-
-          reserved_instances_id = Fog::AWS::Mock.reserved_instances_id
-          reserved_instance_offering.delete('reservedInstancesOfferingId')
-
-          self.data[:reserved_instances][reserved_instances_id] = reserved_instance_offering.merge({
-            'reservedInstancesId' => reserved_instances_id,
-            'start'               => Time.now,
-            'end'                 => Time.now,
-            'instanceCount'       => instance_count,
-            'state'               => 'payment-pending',
-            'tagSet'              => []
-          })
-
-          response.body = {
-            'reservedInstancesId' => reserved_instances_id,
-            'requestId' => Fog::AWS::Mock.request_id
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Reboot specified instances
-        #
-        # ==== Parameters
-        # * instance_id<~Array> - Ids of instances to reboot
-        #
-        # ==== Returns
-        # # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-RebootInstances.html]
-        def reboot_instances(instance_id = [])
-          params = Fog::AWS.indexed_param('InstanceId', instance_id)
-          request({
-            'Action'    => 'RebootInstances',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(params))
-        end
-      end
-
-      class Mock
-        def reboot_instances(instance_id = [])
-          response = Excon::Response.new
-          instance_id = [*instance_id]
-          if (self.data[:instances].keys & instance_id).length == instance_id.length
-            for instance_id in instance_id
-              self.data[:instances][instance_id]['status'] = 'rebooting'
-            end
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,133 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/register_image'
-
-        # register an image
-        #
-        # ==== Parameters
-        # * Name<~String> - Name of the AMI to be registered
-        # * Description<~String> - AMI description
-        # * Location<~String> - S3 manifest location (for S3 backed AMIs)
-        # or
-        # * RootDeviceName<~String> - Name of Root Device (for EBS snapshot backed AMIs)
-        # * BlockDevices<~Array>:
-        #   * BlockDeviceOptions<~Hash>:
-        #     * DeviceName<~String> - Name of the Block Device
-        #     * VirtualName<~String> - Name of the Virtual Device
-        #     * SnapshotId<~String> - id of the EBS Snapshot
-        #     * VolumeSize<~Integer> - Size of the snapshot (optional)
-        #     * NoDevice<~Boolean> - Do not use an ebs device (def: true)
-        #     * DeleteOnTermation<~Boolean> - Delete EBS volume on instance term (def: true)
-        # * Options<~Hash>:
-        #   * Architecture<~String> - i386 or x86_64
-        #   * KernelId<~String> - kernelId
-        #   * RamdiskId<~String> - ramdiskId
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'imageId'<~String> - Id of newly created AMI
-
-        #
-
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-RegisterImage.html]
-
-        def register_image(name, description, location, block_devices=[], options={})
-          common_options = {
-            'Action'      => 'RegisterImage',
-            'Name'        => name,
-            'Description' => description,
-            :parser       => Fog::Parsers::Compute::AWS::RegisterImage.new
-          }
-
-          # This determines if we are doing a snapshot or a S3 backed AMI.
-          if(location =~ /^\/dev\/(xvd|sd)[a-p]\d{0,2}$/)
-            common_options['RootDeviceName'] = location
-          else
-            common_options['ImageLocation'] = location
-          end
-
-          block_devices.each_with_index do |bd, index|
-            index += 1
-            ["DeviceName","VirtualName"].each do |n|
-              common_options["BlockDeviceMapping.#{index}.#{n}"] = bd[n] if bd[n]
-            end
-            ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
-              common_options["BlockDeviceMapping.#{index}.Ebs.#{n}"] = bd[n] if bd[n]
-            end
-          end
-
-          request(common_options.merge!(options))
-        end
-      end
-
-      class Mock
-        def register_image(name, description, location, block_devices=[], options={})
-          unless name.empty?
-            image = {
-              'imageId' => Fog::AWS::Mock.image_id,
-              'imageLocation' => '',
-              'imageState' => 'pending',
-              'imageOwnerId' => self.data[:owner_id],
-              'isPublic' => false,
-              'productCodes' => [],
-              'architecture' => options['Architecture'] || 'i386',
-              'imageType' => 'machine',
-              'kernelId' => options['KernelId'] || Fog::AWS::Mock.kernel_id,
-              'ramdiskId' => options['RamdiskId'] || Fog::AWS::Mock.ramdisk_id,
-              'platform' => 'Linux',
-              'stateReason' => {},
-              'imageOwnerAlias' => self.data[:owner_id],
-              'name' => name,
-              'description' => description,
-              'rootDeviceType' => '',
-              'rootDeviceName' => '',
-              'blockDeviceMapping' => [],
-              'virtualizationType' => 'paravirtual',
-              'hypervisor' => 'xen',
-              'registered' => Time.now
-            }
-
-            if location[/^\/dev\/(xvd|sd)[a-p]\d{0,2}$/]
-              image['rootDeviceName'] = location
-              image['rootDeviceType'] = 'ebs'
-            else
-              image['imageLocation'] = location
-            end
-
-            block_devices.each do |bd|
-              block_device_mapping = {
-                'ebs' => {}
-              }
-              ["DeviceName","VirtualName"].each do |n|
-                block_device_mapping[n] = bd[n] if bd[n]
-              end
-              ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
-                block_device_mapping['ebs'][n] = bd[n] if bd[n]
-              end
-              image['blockDeviceMapping'] << block_device_mapping
-            end
-
-            self.data[:images][image['imageId']] = image
-
-            response = Excon::Response.new
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'imageId' => image['imageId']
-            }
-            response
-          else
-            message = 'MissingParameter => '
-            if name.empty?
-              message << 'The request must contain the parameter name'
-            end
-            raise Fog::Compute::AWS::Error.new(message)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Release an elastic IP address.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ReleaseAddress.html]
-        #
-        # non-VPC: requires public_ip only
-        #     VPC: requires allocation_id only
-        def release_address(ip_or_allocation)
-          field = if ip_or_allocation.to_s =~ /^(\d|\.)+$/
-                    "PublicIp"
-                  else
-                    "AllocationId"
-                  end
-          request(
-            'Action'    => 'ReleaseAddress',
-            field       => ip_or_allocation,
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def release_address(public_ip_or_allocation_id)
-          response = Excon::Response.new
-
-          address = self.data[:addresses][public_ip_or_allocation_id] || self.data[:addresses].values.find {|a| a['allocationId'] == public_ip_or_allocation_id }
-
-          if address
-            if address['allocationId'] && public_ip_or_allocation_id == address['publicIp']
-              raise Fog::Compute::AWS::Error, "InvalidParameterValue => You must specify an allocation id when releasing a VPC elastic IP address"
-            end
-
-            self.data[:addresses].delete(address['publicIp'])
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip_or_allocation_id}' does not belong to you.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/replace_network_acl_association'
-
-        # Replace the network ACL for a subnet with a
-        #
-        # ==== Parameters
-        # * association_id<~String> - The ID of the current association between the original network ACL and the subnet
-        # * network_acl_id<~String> - The ID of the network ACL
-        #
-        # === Returns
-        # * response<~Excon::Response>:
-        # * body<~Hash>:
-        # * 'requestId'<~String> - Id of request
-        # * 'return'<~Boolean> - Returns true if the request succeeds.
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceNetworkAclAssociation.html]
-        def replace_network_acl_association(association_id, network_acl_id)
-          request({
-            'Action'        => 'ReplaceNetworkAclAssociation',
-            'AssociationId' => association_id,
-            'NetworkAclId'  => network_acl_id,
-            :parser         => Fog::Parsers::Compute::AWS::ReplaceNetworkAclAssociation.new
-          })
-        end
-      end
-
-      class Mock
-        def replace_network_acl_association(association_id, network_acl_id)
-          response = Excon::Response.new
-          if self.data[:network_acls][network_acl_id]
-            # find the old assoc
-            old_nacl = self.data[:network_acls].values.find do |n|
-              n['associationSet'].find { |assoc| assoc['networkAclAssociationId'] == association_id }
-            end
-
-            unless old_nacl
-              raise Fog::Compute::AWS::Error.new("Invalid association_id #{association_id}")
-            end
-
-            subnet_id = old_nacl['associationSet'].find { |assoc| assoc['networkAclAssociationId'] == association_id }['subnetId']
-            old_nacl['associationSet'].delete_if { |assoc| assoc['networkAclAssociationId'] == association_id }
-
-            id = Fog::AWS::Mock.network_acl_association_id
-            self.data[:network_acls][network_acl_id]['associationSet'] << {
-              'networkAclAssociationId' => id,
-              'networkAclId'            => network_acl_id,
-              'subnetId'                => subnet_id,
-            }
-
-            response.status = 200
-            response.body = {
-              'requestId'        => Fog::AWS::Mock.request_id,
-              'newAssociationId' => id
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,81 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Replaces a Network ACL entry with the same rule number
-        #
-        # ==== Parameters
-        # * network_acl_id<~String> - The ID of the ACL to add this entry to
-        # * rule_number<~Integer>   - The rule number for the entry, between 100 and 32766
-        # * protocol<~Integer>      - The IP protocol to which the rule applies. You can use -1 to mean all protocols.
-        # * rule_action<~String>    - Allows or denies traffic that matches the rule. (either allow or deny)
-        # * cidr_block<~String>     - The CIDR range to allow or deny
-        # * egress<~Boolean>        - Indicates whether this rule applies to egress traffic from the subnet (true) or ingress traffic to the subnet (false).
-        # * options<~Hash>:
-        # *   'Icmp.Code'           - ICMP code, required if protocol is 1
-        # *   'Icmp.Type'           - ICMP type, required if protocol is 1
-        # *   'PortRange.From'      - The first port in the range, required if protocol is 6 (TCP) or 17 (UDP)
-        # *   'PortRange.To'        - The last port in the range, required if protocol is 6 (TCP) or 17 (UDP)
-        #
-        # === Returns
-        # * response<~Excon::Response>:
-        # * body<~Hash>:
-        # * 'requestId'<~String> - Id of request
-        # * 'return'<~Boolean> - Returns true if the request succeeds.
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceNetworkAclEntry.html]
-        def replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
-          request({
-            'Action'       => 'ReplaceNetworkAclEntry',
-            'NetworkAclId' => network_acl_id,
-            'RuleNumber'   => rule_number,
-            'Protocol'     => protocol,
-            'RuleAction'   => rule_action,
-            'Egress'       => egress,
-            'CidrBlock'    => cidr_block,
-            :parser        => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def replace_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
-          response = Excon::Response.new
-          if self.data[:network_acls][network_acl_id]
-
-            unless self.data[:network_acls][network_acl_id]['entrySet'].find { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
-              raise Fog::Compute::AWS::Error.new("No rule with that number")
-            end
-            self.data[:network_acls][network_acl_id]['entrySet'].delete_if { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
-
-            data = {
-              'ruleNumber'   => rule_number,
-              'protocol'     => protocol,
-              'ruleAction'   => rule_action,
-              'egress'       => egress,
-              'cidrBlock'    => cidr_block,
-              'icmpTypeCode' => {},
-              'portRange'    => {}
-            }
-            data['icmpTypeCode']['code'] = options['Icmp.Code']      if options['Icmp.Code']
-            data['icmpTypeCode']['type'] = options['Icmp.Type']      if options['Icmp.Type']
-            data['portRange']['from']    = options['PortRange.From'] if options['PortRange.From']
-            data['portRange']['to']      = options['PortRange.To']   if options['PortRange.To']
-            self.data[:network_acls][network_acl_id]['entrySet'] << data
-
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The network ACL '#{network_acl_id}' does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Replaces a route in a route table within a VPC.
-        #
-        # ==== Parameters
-        # * RouteTableId<~String> - The ID of the route table for the route.
-        # * options<~Hash>:
-        #   * DestinationCidrBlock<~String> - The CIDR address block used for the destination match. Routing decisions are based on the most specific match.
-        #   * GatewayId<~String> - The ID of an Internet gateway attached to your VPC.
-        #   * InstanceId<~String> - The ID of a NAT instance in your VPC. The operation fails if you specify an instance ID unless exactly one network interface is attached.
-        #   * NetworkInterfaceId<~String> - The ID of a network interface.
-        #
-        # === Returns
-        # * response<~Excon::Response>:
-        # * body<~Hash>:
-        # * 'requestId'<~String> - Id of the request
-        # * 'return'<~Boolean> - Returns true if the request succeeds. Otherwise, returns an error.
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-ReplaceRoute.html]
-        def replace_route(route_table_id, destination_cidr_block, options = {})
-          options['DestinationCidrBlock'] ||= destination_cidr_block
-
-          request({
-            'Action' => 'ReplaceRoute',
-            'RouteTableId' => route_table_id,
-            :idempotent => true,
-            :parser => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def replace_route(route_table_id, destination_cidr_block, options = {})
-          options['instanceOwnerId'] ||= nil
-          options['DestinationCidrBlock'] ||= destination_cidr_block
-
-          route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
-          if !route_table.nil? && destination_cidr_block
-            if !options['gatewayId'].nil? || !options['instanceId'].nil? || !options['networkInterfaceId'].nil?
-              if !options['gatewayId'].nil? && self.internet_gateways.all('internet-gateway-id'=>options['gatewayId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{options['gatewayId']}' does not exist")
-              elsif !options['instanceId'].nil? && self.servers.all('instance-id'=>options['instanceId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{options['instanceId']}' does not exist")
-              elsif !options['networkInterfaceId'].nil? && self.network_interfaces.all('networkInterfaceId'=>options['networkInterfaceId']).first.nil?
-                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{options['networkInterfaceId']}' does not exist")
-              elsif route_table['routeSet'].find { |route| route['destinationCidrBlock'].eql? destination_cidr_block }.nil?
-                raise Fog::Compute::AWS::Error, "RouteAlreadyExists => The route identified by #{destination_cidr_block} doesn't exist."
-              else
-                response = Excon::Response.new
-                route_set = route_table['routeSet'].find { |routeset| routeset['destinationCidrBlock'].eql? destination_cidr_block }
-                route_set.merge!(options)
-                route_set['state'] = 'pending'
-                route_set['origin'] = 'ReplaceRoute'
-
-                response.status = 200
-                response.body = {
-                  'requestId'=> Fog::AWS::Mock.request_id,
-                  'return' => true
-                }
-                response
-              end
-            else
-              message = 'MissingParameter => '
-              message << 'The request must contain either a gateway id, a network interface id, or an instance id'
-              raise Fog::Compute::AWS::Error.new(message)
-            end
-          elsif route_table.nil?
-            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{route_table_id}' does not exist")
-          elsif destination_cidr_block.empty?
-            raise Fog::Compute::AWS::InvalidParameterValue.new("Value () for parameter destinationCidrBlock is invalid. This is not a valid CIDR block.")
-          end
-        end
-      end
-    end
-  end
-end