fog 1.26.0 → 1.27.0

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

@@ -1,52 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-        # Detaches 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 detach
-        # * 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-DetachInternetGateway.html]
-        def detach_internet_gateway(internet_gateway_id, vpc_id)
-          request(
-            'Action'               => 'DetachInternetGateway',
-            'InternetGatewayId'    => internet_gateway_id,
-            'VpcId'                => vpc_id,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def detach_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/detach_network_interface.rb

@@ -1,48 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-        # Detaches a network interface.
-        #
-        # ==== Parameters
-        # * attachment_id<~String> - ID of the attachment to detach
-        # * force<~Boolean>        - Set to true to force a detachment
-        #
-        # === 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/2012-03-01/APIReference/ApiReference-query-DetachNetworkInterface.html]
-        def detach_network_interface(attachment_id, force = false)
-          request(
-            'Action'       => 'DetachNetworkInterface',
-            'AttachmentId' => attachment_id,
-            'Force'        => force,
-            :parser        => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def detach_network_interface(attachment_id, force = false)
-          response = Excon::Response.new
-          nic_id = self.data[:network_interfaces].select { |k,v| v['attachment']['attachmentId'] == attachment_id} .first.first
-          if nic_id
-            self.data[:network_interfaces][nic_id]["attachment"] = {}
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The network interface '#{network_interface_id}' does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/detach_volume'
-
-        # Detach an Amazon EBS volume from a running instance
-        #
-        # ==== Parameters
-        # * volume_id<~String> - Id of amazon EBS volume to associate with instance
-        # * options<~Hash>:
-        #   * 'Device'<~String> - Specifies how the device is exposed to the instance (e.g. "/dev/sdh")
-        #   * 'Force'<~Boolean> - If true forces detach, can cause data loss/corruption
-        #   * 'InstanceId'<~String> - Id of instance to associate volume with
-        #
-        # ==== 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-DetachVolume.html]
-        def detach_volume(volume_id, options = {})
-          request({
-            'Action'    => 'DetachVolume',
-            'VolumeId'  => volume_id,
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::DetachVolume.new
-          }.merge!(options))
-        end
-      end
-
-      class Mock
-        def detach_volume(volume_id, options = {})
-          response = Excon::Response.new
-          response.status = 200
-          if (volume = self.data[:volumes][volume_id])
-            if !volume['attachmentSet'].empty?
-              data = volume['attachmentSet'].pop
-              volume['status'] = 'available'
-              response.status = 200
-              response.body = {
-                'requestId' => Fog::AWS::Mock.request_id
-              }.merge!(data)
-              response
-            else
-              # real response has spacing issue below
-              raise Fog::Compute::AWS::Error.new("IncorrectState => Volume '#{volume_id}'is in the 'available' state.")
-            end
-          else
-            raise Fog::Compute::AWS::NotFound.new("The volume '#{volume_id}' does not exist.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Disassociate an elastic IP address from its instance (if any)
-        #
-        # ==== Parameters
-        # * public_ip<~String> - Public ip to assign to instance
-        # * association_id<~String> - Id associating eip to an network interface
-        #
-        # ==== 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-DisassociateAddress.html]
-        def disassociate_address(public_ip=nil, association_id=nil)
-          request(
-            'Action'        => 'DisassociateAddress',
-            'PublicIp'      => public_ip,
-            'AssociationId' => association_id,
-            :idempotent     => true,
-            :parser         => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def disassociate_address(public_ip)
-          response = Excon::Response.new
-          response.status = 200
-          if address = self.data[:addresses][public_ip]
-            instance_id = address['instanceId']
-            if instance = self.data[:instances][instance_id]
-              instance['ipAddress']         = instance['originalIpAddress']
-              instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
-            end
-            address['instanceId'] = nil
-            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}' does not belong to you.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Disassociates a subnet from a route table.
-        #
-        # ==== Parameters
-        # * AssociationId<~String> - The association ID representing the current association between the route table and subnet.
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - The 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-DisassociateRouteTable.html]
-        def disassociate_route_table(association_id)
-          request(
-            'Action'        => 'DisassociateRouteTable',
-            'AssociationId' => association_id,
-            :parser         => Fog::Parsers::Compute::AWS::Basic.new
-          )
-        end
-      end
-
-      class Mock
-        def disassociate_route_table(association_id)
-          assoc_array = nil
-          routetable = self.data[:route_tables].find { |routetable|
-            assoc_array = routetable["associationSet"].find { |association|
-              association['routeTableAssociationId'].eql? association_id
-            }
-          }
-          if !assoc_array.nil? && assoc_array['main'] == false
-            routetable['associationSet'].delete(assoc_array)
-            response = Excon::Response.new
-            response.status = 200
-            response.body = {
-                'requestId'     => Fog::AWS::Mock.request_id,
-                'return'        => true
-            }
-            response
-          elsif assoc_array.nil?
-            raise Fog::Compute::AWS::NotFound.new("The association ID '#{association_id}' does not exist")
-          elsif assoc_array['main'] == true
-            raise Fog::Compute::AWS::Error, "InvalidParameterValue => cannot disassociate the main route table association #{association_id}"
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/get_console_output'
-
-        # Retrieve console output for specified instance
-        #
-        # ==== Parameters
-        # * instance_id<~String> - Id of instance to get console output from
-        #
-        # ==== Returns
-        # # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'instanceId'<~String> - Id of instance
-        #     * 'output'<~String> - Console output
-        #     * 'requestId'<~String> - Id of request
-        #     * 'timestamp'<~Time> - Timestamp of last update to output
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-GetConsoleOutput.html]
-        def get_console_output(instance_id)
-          request(
-            'Action'      => 'GetConsoleOutput',
-            'InstanceId'  => instance_id,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::GetConsoleOutput.new
-          )
-        end
-      end
-
-      class Mock
-        def get_console_output(instance_id)
-          response = Excon::Response.new
-          if instance = self.data[:instances][instance_id]
-            response.status = 200
-            response.body = {
-              'instanceId'    => instance_id,
-              'output'        => (Time.now - instance['launchTime'] >= Fog::Mock.delay) ? nil : Fog::AWS::Mock.console_output,
-              'requestId'     => Fog::AWS::Mock.request_id,
-              'timestamp'     => Time.now
-            }
-            response
-          else;
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/get_password_data'
-
-        # Retrieves the encrypted administrator password for an instance running Windows.
-        #
-        # ==== Parameters
-        # * instance_id<~String> - A Windows instance ID
-        #
-        # ==== Returns
-        # # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'instanceId'<~String> - Id of instance
-        #     * 'passwordData'<~String> - The encrypted, base64-encoded password of the instance.
-        #     * 'requestId'<~String> - Id of request
-        #     * 'timestamp'<~Time> - Timestamp of last update to output
-        #
-        # See http://docs.amazonwebservices.com/AWSEC2/2010-08-31/APIReference/index.html?ApiReference-query-GetPasswordData.html
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-GetPasswordData.html]
-        def get_password_data(instance_id)
-          request(
-            'Action'      => 'GetPasswordData',
-            'InstanceId'  => instance_id,
-            :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::GetPasswordData.new
-          )
-        end
-      end
-
-      class Mock
-        def get_password_data(instance_id)
-          response = Excon::Response.new
-          if instance = self.data[:instances][instance_id]
-            response.status = 200
-            response.body = {
-              'instanceId'   => instance_id,
-              'passwordData' => nil,
-              'requestId'    => Fog::AWS::Mock.request_id,
-              'timestamp'    => Time.now
-            }
-            response
-          else;
-            raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/import_key_pair'
-
-        # Import an existing public key to create a new key pair
-        #
-        # ==== Parameters
-        # * key_name<~String> - Unique name for key pair.
-        # * public_key_material<~String> - RSA public key
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
-        #     * 'keyName'<~String> - Name of key
-        #     * 'requestId'<~String> - Id of request
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ImportKeyPair.html]
-        def import_key_pair(key_name, public_key_material)
-          request(
-            'Action'  => 'ImportKeyPair',
-            'KeyName' => key_name,
-            'PublicKeyMaterial' => Base64::encode64(public_key_material),
-            :parser   => Fog::Parsers::Compute::AWS::ImportKeyPair.new
-          )
-        end
-      end
-
-      class Mock
-        def import_key_pair(key_name, public_key_material)
-          response = Excon::Response.new
-          unless self.data[:key_pairs][key_name]
-            response.status = 200
-            data = {
-              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
-              'keyName'         => key_name
-            }
-            self.data[:key_pairs][key_name] = data
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id
-            }.merge!(data)
-            response
-          else
-            raise Fog::Compute::AWS::Error.new("InvalidKeyPair.Duplicate => The keypair '#{key_name}' already exists.")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Modify image attributes
-        #
-        # ==== Parameters
-        # * image_id<~String> - Id of machine image to modify
-        # * attributes<~Hash>:
-        #   * 'Add.Group'<~Array> - One or more groups to grant launch permission to
-        #   * 'Add.UserId'<~Array> - One or more account ids to grant launch permission to
-        #   * 'Description.Value'<String> - New description for image
-        #   * 'ProductCode'<~Array> - One or more product codes to add to image (these can not be removed)
-        #   * 'Remove.Group'<~Array> - One or more groups to revoke launch permission from
-        #   * 'Remove.UserId'<~Array> - One or more account ids to revoke launch permission from
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-ModifyImageAttribute.html]
-        #
-        def modify_image_attribute(image_id, attributes)
-          raise ArgumentError.new("image_id is required") unless image_id
-
-          params = {}
-          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Add.%d.Group', attributes['Add.Group'] || []))
-          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Add.%d.UserId', attributes['Add.UserId'] || []))
-          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Remove.%d.Group', attributes['Remove.Group'] || []))
-          params.merge!(Fog::AWS.indexed_param('LaunchPermission.Remove.%d.UserId', attributes['Remove.UserId'] || []))
-          params.merge!(Fog::AWS.indexed_param('ProductCode', attributes['ProductCode'] || []))
-          request({
-            'Action'        => 'ModifyImageAttribute',
-            'ImageId'       => image_id,
-            :idempotent     => true,
-            :parser         => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(params))
-        end
-      end
-
-      class Mock
-        def modify_image_attribute(image_id, attributes)
-          raise ArgumentError.new("image_id is required") unless image_id
-
-          unless self.data[:images][image_id]
-            raise Fog::Compute::AWS::NotFound.new("The AMI ID '#{image_id}' does not exist")
-          end
-
-          (attributes['Add.UserId'] || []).each do |user_id|
-            if image_launch_permissions = self.data[:image_launch_permissions][image_id]
-              image_launch_permissions[:users].push(user_id)
-            end
-          end
-
-          (attributes['Remove.UserId'] || []).each do |user_id|
-            if image_launch_permissions = self.data[:image_launch_permissions][image_id]
-              image_launch_permissions[:users].delete(user_id)
-            end
-          end
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            'return'        => true,
-            'requestId'     => Fog::AWS::Mock.request_id
-          }
-          response
-        end
-      end
-    end
-  end
-end