fog 1.26.0 → 1.27.0

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

@@ -1,126 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/associate_address'
-
-        # Associate an elastic IP address with an instance
-        #
-        # ==== Parameters
-        # * instance_id<~String> - Id of instance to associate address with (conditional)
-        # * public_ip<~String> - Public ip to assign to instance (conditional)
-        # * network_interface_id<~String> - Id of a nic to associate address with (required in a vpc instance with more than one nic) (conditional)
-        # * allocation_id<~String> - Allocation Id to associate address with (vpc only) (conditional)
-        # * private_ip_address<~String> - Private Ip Address to associate address with (vpc only)
-        # * allow_reassociation<~Boolean> - Allows an elastic ip address to be reassigned  (vpc only) (conditional)
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - success?
-        #     * 'associationId'<~String> - association Id for eip to node (vpc only)
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateAddress.html]
-        def associate_address(*args)
-          if args.first.kind_of? Hash
-            params = args.first
-          else
-            params = {
-                :instance_id => args[0],
-                :public_ip => args[1],
-                :network_interface_id => args[2],
-                :allocation_id => args[3],
-                :private_ip_address => args[4],
-                :allow_reassociation => args[5],
-            }
-          end
-          # Cannot specify an allocation ip and a public IP at the same time.  If you have an allocation Id presumably you are in a VPC
-          # so we will null out the public IP
-          params[:public_ip] = params[:allocation_id].nil? ? params[:public_ip] : nil
-
-          request(
-            'Action'             => 'AssociateAddress',
-            'AllocationId'       => params[:allocation_id],
-            'InstanceId'         => params[:instance_id],
-            'NetworkInterfaceId' => params[:network_interface_id],
-            'PublicIp'           => params[:public_ip],
-            'PrivateIpAddress'   => params[:private_ip_address],
-            'AllowReassociation' => params[:allow_reassociation],
-            :idempotent          => true,
-            :parser              => Fog::Parsers::Compute::AWS::AssociateAddress.new
-          )
-        end
-      end
-
-      class Mock
-        def associate_address(*args)
-          if args.first.kind_of? Hash
-            params = args.first
-          else
-            params = {
-                :instance_id => args[0],
-                :public_ip => args[1],
-                :network_interface_id => args[2],
-                :allocation_id => args[3],
-                :private_ip_address => args[4],
-                :allow_reassociation => args[5],
-            }
-          end
-          params[:public_ip] = params[:allocation_id].nil? ? params[:public_ip] : nil
-          response = Excon::Response.new
-          response.status = 200
-          instance = self.data[:instances][params[:instance_id]]
-         # address =  self.data[:addresses][params[:public_ip]]
-          address = params[:public_ip].nil? ? nil : self.data[:addresses][params[:public_ip]]
-          # This is a classic server, a VPC with a single network interface id or a VPC with multiple network interfaces one of which is specified
-          if ((instance && address) || (instance &&  !params[:allocation_id].nil?) || (!params[:allocation_id].nil? && !network_interface_id.nil?))
-            if !params[:allocation_id].nil?
-              allocation_ip = describe_addresses( 'allocation-id'  => "#{params[:allocation_id]}").body['addressesSet'].first
-              if !allocation_ip.nil?
-                public_ip = allocation_ip['publicIp']
-                address = public_ip.nil? ? nil : self.data[:addresses][public_ip]
-              end
-            end
-            if !address.nil?
-              if current_instance = self.data[:instances][address['instanceId']]
-                current_instance['ipAddress'] = current_instance['originalIpAddress']
-              end
-              address['instanceId'] = params[:instance_id]
-            end
-            # detach other address (if any)
-            if self.data[:addresses][instance['ipAddress']]
-              self.data[:addresses][instance['ipAddress']]['instanceId'] = nil
-            end
-            if !params[:public_ip].nil?
-              instance['ipAddress'] = params[:public_ip]
-              instance['dnsName'] = Fog::AWS::Mock.dns_name_for(params[:public_ip])
-            end
-            response.status = 200
-            if !params[:instance_id].nil? && !params[:public_ip].nil?
-              response.body = {
-                'requestId' => Fog::AWS::Mock.request_id,
-                'return'    => true
-              }
-            elsif !params[:allocation_id].nil?
-              response.body = {
-                'requestId'     => Fog::AWS::Mock.request_id,
-                'return'        => true,
-                'associationId' => Fog::AWS::Mock.request_id
-              }
-            end
-            response
-          elsif !instance
-            raise Fog::Compute::AWS::NotFound.new("You must specify either an InstanceId or a NetworkInterfaceID")
-          elsif !address
-            raise Fog::Compute::AWS::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
-          elsif params[:network_interface_id].nil? && params[:allocation_id].nil?
-            raise Fog::Compute::AWS::NotFound.new("You must specify an AllocationId when specifying a NetworkInterfaceID")
-          else (!instance.nil? && params[:network_interface_id].nil?) || (params[:instance_id].nil? && !params[:network_interface_id].nil?)
-            raise Fog::Compute::AWS::Error.new("You must specify either an InstanceId or a NetworkInterfaceID")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-        #
-        #
-        # ==== Parameters
-        # * dhcp_options_id<~String> - The ID of the DHCP options you want to associate with the VPC, or "default" if you want the VPC
-        #   to use no DHCP options.
-        # * vpc_id<~String> - The ID of the VPC
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - Returns true if the request succeeds.
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateDhcpOptions.html]
-        def associate_dhcp_options(dhcp_options_id, vpc_id)
-          request(
-            'Action'               => 'AssociateDhcpOptions',
-            'DhcpOptionsId'        => dhcp_options_id,
-            'VpcId'                => vpc_id,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def associate_dhcp_options(dhcp_options_id, vpc_id)
-          response = Excon::Response.new
-          if dhcp_options_id && vpc_id
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return' => true
-            }
-            response
-          else
-            if !dhcp_options_id
-              message << 'The request must contain the parameter dhcp_options_id'
-            elsif !vpc_id
-              message << 'The request must contain the parameter vpc_id'
-            end
-            raise Fog::Compute::AWS::Error.new(message)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/associate_route_table'
-        # Associates a subnet with a route table.
-        #
-        # ==== Parameters
-        # * RouteTableId<~String> - The ID of the route table
-        # * SubnetId<~String> - The ID of the subnet
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - The ID of the request
-        #     * 'associationId'<~String> - The route table association ID (needed to disassociate the route table)
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateRouteTable.html]
-        def associate_route_table(routeTableId, subnetId)
-          request(
-            'Action'       => 'AssociateRouteTable',
-            'RouteTableId' => routeTableId,
-            'SubnetId'     => subnetId,
-            :parser        => Fog::Parsers::Compute::AWS::AssociateRouteTable.new
-          )
-        end
-      end
-
-      class Mock
-        def associate_route_table(routeTableId, subnetId)
-          routetable = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? routeTableId }
-          subnet = self.data[:subnets].find { |subnet| subnet["subnetId"].eql? subnetId }
-
-          if !routetable.nil? && !subnet.nil?
-            response = Excon::Response.new
-            response.status = 200
-            association = add_route_association(routeTableId, subnetId)
-            routetable["associationSet"].push(association)
-            response.body = {
-                'requestId'     => Fog::AWS::Mock.request_id,
-                'associationId' => association['routeTableAssociationId']
-            }
-            response
-          elsif routetable.nil?
-            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{routeTableId}' does not exist")
-          else
-            raise Fog::Compute::AWS::NotFound.new("The subnet ID '#{subnetId}' does not exist")
-          end
-        end
-
-        private
-
-        def add_route_association(routeTableId, subnetId, main=nil)
-          response = {
-              "routeTableAssociationId" => "rtbassoc-#{Fog::Mock.random_hex(8)}",
-              "routeTableId" => routeTableId,
-              "subnetId" => nil,
-              "main" => false
-            }
-          if main
-            response['main'] = true
-          else
-            response['subnetId'] = subnetId
-          end
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-        # Attaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC
-        #
-        # ==== Parameters
-        # * internet_gateway_id<~String> - The ID of the Internet gateway to attach
-        # * vpc_id<~String> - The ID of the VPC
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #     * 'return'<~Boolean> - Returns true if the request succeeds.
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AttachInternetGateway.html]
-        def attach_internet_gateway(internet_gateway_id, vpc_id)
-          request(
-            'Action'               => 'AttachInternetGateway',
-            'InternetGatewayId'    => internet_gateway_id,
-            'VpcId'                => vpc_id,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def attach_internet_gateway(internet_gateway_id, vpc_id)
-          response = Excon::Response.new
-          if internet_gateway_id && vpc_id
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return' => true
-            }
-            response
-          else
-            if !internet_gateway_id
-              message << 'The request must contain the parameter internet_gateway_id'
-            elsif !vpc_id
-              message << 'The request must contain the parameter vpc_id'
-            end
-            raise Fog::Compute::AWS::Error.new(message)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/attach_network_interface'
-
-        # Attach a network interface
-        #
-        # ==== Parameters
-        # * networkInterfaceId<~String> - ID of the network interface to attach
-        # * instanceId<~String>         - ID of the instance that will be attached to the network interface
-        # * deviceIndex<~Integer>       - index of the device for the network interface attachment on the instance
-        #
-        # === Returns
-        # * response<~Excon::Response>:
-        # * body<~Hash>:
-        # * 'requestId'<~String>    - Id of request
-        # * 'attachmentId'<~String> - ID of the attachment
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/index.html?ApiReference-query-AttachNetworkInterface.html]
-        def attach_network_interface(nic_id, instance_id, device_index)
-          request(
-            'Action' => 'AttachNetworkInterface',
-            'NetworkInterfaceId' => nic_id,
-            'InstanceId'         => instance_id,
-            'DeviceIndex'        => device_index,
-            :parser => Fog::Parsers::Compute::AWS::AttachNetworkInterface.new
-          )
-        end
-      end
-
-      class Mock
-        def attach_network_interface(nic_id, instance_id, device_index)
-          response = Excon::Response.new
-          if ! self.data[:instances].find{ |i,i_conf|
-            i_conf['instanceId'] == instance_id
-          }
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
-          elsif self.data[:network_interfaces].find{ |ni,ni_conf| ni_conf['attachment']['instanceId'] == instance_id && ni_conf['attachment']['deviceIndex'] == device_index }
-            raise Fog::Compute::AWS::Error.new("InvalidParameterValue => Instance '#{instance_id}' already has an interface attached at device index '#{device_index}'.")
-          elsif self.data[:network_interfaces][nic_id]
-            attachment = self.data[:network_interfaces][nic_id]['attachment']
-            attachment['attachmentId'] = Fog::AWS::Mock.request_id
-            attachment['instanceId']   = instance_id
-            attachment['deviceIndex']  = device_index
-
-            response.status = 200
-            response.body = {
-              'requestId'    => Fog::AWS::Mock.request_id,
-              'attachmentId' => attachment['attachmentId']
-            }
-          else
-            raise Fog::Compute::AWS::NotFound.new("The network interface '#{nic_id}' does not exist")
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/attach_volume'
-
-        # Attach an Amazon EBS volume with a running instance, exposing as specified device
-        #
-        # ==== Parameters
-        # * instance_id<~String> - Id of instance to associate volume with
-        # * volume_id<~String> - Id of amazon EBS volume to associate with instance
-        # * device<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'attachTime'<~Time> - Time of attachment was initiated at
-        #     * 'device'<~String> - Device as it is exposed to the instance
-        #     * 'instanceId'<~String> - Id of instance for volume
-        #     * 'requestId'<~String> - Id of request
-        #     * 'status'<~String> - Status of volume
-        #     * 'volumeId'<~String> - Reference to volume
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-AttachVolume.html]
-        def attach_volume(instance_id, volume_id, device)
-          request(
-            'Action'      => 'AttachVolume',
-            'VolumeId'    => volume_id,
-            'InstanceId'  => instance_id,
-            'Device'      => device,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::AttachVolume.new
-          )
-        end
-      end
-
-      class Mock
-        def attach_volume(instance_id, volume_id, device)
-          response = Excon::Response.new
-          if instance_id && volume_id && device
-            response.status = 200
-            instance = self.data[:instances][instance_id]
-            volume = self.data[:volumes][volume_id]
-            if instance && volume
-              unless volume['status'] == 'available'
-                raise Fog::Compute::AWS::Error.new("Client.VolumeInUse => Volume #{volume_id} is unavailable")
-              end
-
-              data = {
-                'attachTime'  => Time.now,
-                'device'      => device,
-                'instanceId'  => instance_id,
-                'status'      => 'attaching',
-                'volumeId'    => volume_id
-              }
-              volume['attachmentSet'] = [data]
-              volume['status'] = 'attaching'
-              response.status = 200
-              response.body = {
-                'requestId' => Fog::AWS::Mock.request_id
-              }.merge!(data)
-              response
-            elsif !instance
-              raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist.")
-            elsif !volume
-              raise Fog::Compute::AWS::NotFound.new("The volume '#{volume_id}' does not exist.")
-            end
-          else
-            message = 'MissingParameter => '
-            if !instance_id
-              message << 'The request must contain the parameter instance_id'
-            elsif !volume_id
-              message << 'The request must contain the parameter volume_id'
-            else
-              message << 'The request must contain the parameter device'
-            end
-            raise Fog::Compute::AWS::Error.new(message)
-          end
-        end
-      end
-    end
-  end
-end