fog 0.0.3

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

@@ -0,0 +1,62 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # 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<~Fog::AWS::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
+        def detach_volume(volume_id, options = {})
+          request({
+            'Action' => 'DetachVolume',
+            'VolumeId' => volume_id
+          }.merge!(options), Fog::Parsers::AWS::EC2::DetachVolume.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def detach_volume(volume_id, options = {})
+          response = Fog::Response.new
+          response.status = 200
+          if volume = Fog::AWS::EC2.data[:volumes][volume_id]
+            data = volume['attachmentSet'].pop
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id
+            }.merge!(data)
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,55 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Disassociate an elastic IP address from its instance (if any)
+        #
+        # ==== Parameters
+        # * public_ip<~String> - Public ip to assign to instance
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def disassociate_address(public_ip)
+          request({
+            'Action' => 'DisassociateAddress',
+            'PublicIp' => public_ip
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def disassociate_address(public_ip)
+          response = Fog::Response.new
+          response.status = 200
+          if address = Fog::AWS::EC2.data[:addresses][public_ip]
+            address['instanceId'] = ''
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Retrieve console output for specified instance
+      #
+      # ==== Parameters
+      # * instance_id<~String> - Id of instance to get console output from
+      #
+      # ==== Returns
+      # # * response<~Fog::AWS::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
+      def get_console_output(instance_id)
+        request({
+          'Action' => 'GetConsoleOutput',
+          'InstanceId' => instance_id
+        }, Fog::Parsers::AWS::EC2::GetConsoleOutput.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Reboot specified instances
+      #
+      # ==== Parameters
+      # * instance_id<~Array> - Ids of instances to reboot
+      #
+      # ==== Returns
+      # # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def reboot_instances(instance_id = [])
+        params = indexed_params('InstanceId', instance_id)
+        request({
+          'Action' => 'RebootInstances'
+        }.merge!(params), Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Release an elastic IP address.
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def release_address(public_ip)
+          request({
+            'Action' => 'ReleaseAddress',
+            'PublicIp' => public_ip
+          }, Fog::Parsers::AWS::EC2::Basic.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def release_address(public_ip)
+          response = Fog::Response.new
+          if (address = Fog::AWS::EC2.data[:addresses].delete(public_ip))
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+          else
+            response.status = 400
+            raise(Fog::Errors.status_error(200, 400, response))
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/revoke_security_group_ingress.rb

@@ -0,0 +1,32 @@
+module Fog
+  module AWS
+    class EC2
+
+      # Remove permissions from a security group
+      #
+      # ==== Parameters
+      # * options<~Hash>:
+      #   * 'GroupName'<~String> - Name of group
+      #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
+      #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
+      #   or
+      #   * 'CidrIp' - CIDR range
+      #   * 'FromPort' - Start of port range (or -1 for ICMP wildcard)
+      #   * 'GroupName' - Name of group to modify
+      #   * 'IpProtocol' - Ip protocol, must be in ['tcp', 'udp', 'icmp']
+      #   * 'ToPort' - End of port range (or -1 for ICMP wildcard)
+      #
+      # === Returns
+      # * response<~Fog::AWS::Response>:
+      #   * body<~Hash>:
+      #     * 'requestId'<~String> - Id of request
+      #     * 'return'<~Boolean> - success?
+      def revoke_security_group_ingress(options = {})
+        request({
+          'Action' => 'RevokeSecurityGroupIngress'
+        }.merge!(options), Fog::Parsers::AWS::EC2::Basic.new)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Launch specified instances
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of machine image to load on instances
+        # * min_count<~Integer> - Minimum number of instances to launch. If this
+        #   exceeds the count of available instances, no instances will be
+        #   launched.  Must be between 1 and maximum allowed for your account
+        #   (by default the maximum for an account is 20)
+        # * max_count<~Integer> - Maximum number of instances to launch. If this
+        #   exceeds the number of available instances, the largest possible
+        #   number of instances above min_count will be launched instead. Must
+        #   be between 1 and maximum allowed for you account
+        #   (by default the maximum for an account is 20)
+        # * options<~Hash>:
+        #   * 'Placement.AvailabilityZone'<~String> - Placement constraint for instances
+        #   * 'DeviceName'<~String> - ?
+        #   * 'Encoding'<~String> - ?
+        #   * 'GroupId'<~String> - Name of security group for instances
+        #   * 'InstanceType'<~String> - Type of instance to boot. Valid options
+        #     in ['m1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge']
+        #     default is 'm1.small'
+        #   * 'KernelId'<~String> - Id of kernel with which to launch
+        #   * 'KeyName'<~String> - Name of a keypair to add to booting instances
+        #   * 'Monitoring.Enabled'<~Boolean> - Enables monitoring, defaults to 
+        #     disabled
+        #   * 'RamdiskId'<~String> - Id of ramdisk with which to launch
+        #   * 'UserData'<~String> -  Additional data to provide to booting instances
+        #   * 'Version'<~String> - ?
+        #   * 'VirtualName'<~String> - ?
+        #
+        # ==== Returns
+        # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'groupSet'<~Array>: groups the instances are members in
+        #       * 'groupName'<~String> - Name of group
+        #     * 'instancesSet'<~Array>: returned instances
+        #       * instance<~Hash>:
+        #         * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
+        #         * '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
+        #         * 'instanceState'<~Hash>:
+        #           * 'code'<~Integer> - current status code
+        #           * 'name'<~String> - current status name
+        #         * 'instanceType'<~String> - type of instance
+        #         * 'kernelId'<~String> - Id of kernel used to launch instance
+        #         * 'keyName'<~String> - name of key used launch instances or blank
+        #         * 'launchTime'<~Time> - time instance was launched
+        #         * 'monitoring'<~Hash>:
+        #           * 'state'<~Boolean - state of monitoring
+        #         * 'placement'<~Hash>:
+        #           * 'availabilityZone'<~String> - Availability zone of the instance
+        #         * 'privateDnsName'<~String> - private dns name, blank until instance is running
+        #         * 'productCodes'<~Array> - Product codes for the instance
+        #         * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
+        #         * 'reason'<~String> - reason for most recent state transition, or blank
+        #     * 'ownerId'<~String> - Id of owner
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservationId'<~String> - Id of reservation
+        def run_instances(image_id, min_count, max_count, options = {})
+          request({
+            'Action' => 'RunInstances',
+            'ImageId' => image_id,
+            'MinCount' => min_count,
+            'MaxCount' => max_count
+          }.merge!(options), Fog::Parsers::AWS::EC2::RunInstances.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def run_instances(image_id, min_count, max_count, options = {})
+          response = Fog::Response.new
+          response.status = 200
+
+          group_set = [ (options['GroupId'] || 'default') ]
+          instances_set = []
+          owner_id = Fog::AWS::Mock.owner_id
+          reservation_id = Fog::AWS::Mock.reservation_id
+
+          min_count.times do |i|
+            instance_id = Fog::AWS::Mock.instance_id
+            data = {
+              'amiLaunchIndex'  => i,
+              'dnsName'         => '',
+              'groupSet'        => group_set,
+              'imageId'         => image_id,
+              'instanceId'      => instance_id,
+              'instanceState'   => { 'code' => 0, 'name' => 'pending' },
+              'instanceType'    => options['InstanceType'] || 'm1.small',
+              'kernelId'        => options['KernelId'] || Fog::AWS::Mock.kernel_id,
+              'keyName'         => options['KeyName'] || '',
+              'launchTime'      => Time.now,
+              'monitoring'      => { 'state' => options['Monitoring.Enabled'] || false },
+              'ownerId'         => owner_id,
+              'placement'       => { 'availabilityZone' => options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone },
+              'privateDnsName'  => '',
+              'productCodes'    => [],
+              'ramdiskId'       => options['RamdiskId'] || Fog::AWS::Mock.ramdisk_id,
+              'reason'          => '',
+              'reservationId'   => reservation_id,
+              'state'           => 'pending'
+            }
+            Fog::AWS::EC2.data[:instances][instance_id] = data
+            instances_set << data.reject{|key,value| !['amiLaunchIndex', 'dnsName', 'imageId', 'instanceId', 'instanceState', 'instanceType', 'kernelId', 'keyName', 'launchTime', 'monitoring', 'placement', 'privateDnsName', 'productCodes', 'ramdiskId', 'reason'].include?(key)}
+          end
+          response.body = {
+            'groupSet'      => group_set,
+            'instancesSet'  => instances_set,
+            'ownerId'       => owner_id,
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'reservationId' => reservation_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+
+end

data/lib/fog/aws/requests/ec2/terminate_instances.rb

@@ -0,0 +1,80 @@
+unless Fog.mocking?
+
+  module Fog
+    module AWS
+      class EC2
+
+        # Terminate specified instances
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - Ids of instances to terminates
+        #
+        # ==== Returns
+        # # * response<~Fog::AWS::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'instancesSet'<~Array>:
+        #       * 'instanceId'<~String> - id of the terminated instance
+        #       * 'previousState'<~Hash>: previous state of instance
+        #         * 'code'<~Integer> - previous status code
+        #         * 'name'<~String> - name of previous state
+        #       * 'shutdownState'<~Hash>: shutdown state of instance
+        #         * 'code'<~Integer> - current status code
+        #         * 'name'<~String> - name of current state
+        def terminate_instances(instance_id)
+          params = indexed_params('InstanceId', instance_id)
+          request({
+            'Action' => 'TerminateInstances'
+          }.merge!(params), Fog::Parsers::AWS::EC2::TerminateInstances.new)
+        end
+
+      end
+    end
+  end
+
+else
+
+  module Fog
+    module AWS
+      class EC2
+
+        def terminate_instances(instance_id)
+          instance_id = [*instance_id]
+          response = Fog::Response.new
+          instance_id.each do |instance_id|
+            response.body = {
+              'requestId'     => Fog::AWS::Mock.request_id,
+              'instancesSet'  => []
+            }
+            if instance = Fog::AWS::EC2.data[:instances][instance_id]
+              Fog::AWS::EC2.data[:deleted_at][instance_id] = Time.now
+              instance['status'] = 'deleting'
+              response.status = 200
+              code = case instance['state']
+              when 'pending'
+                0
+              when 'running'
+                16
+              when 'shutting-down'
+                32
+              when 'terminated'
+                64
+              end
+              response.body['instancesSet'] << {
+                'instanceId'    => instance_id,
+                'previousState' => { 'name' => instance['state'], 'code' => code },
+                'shutdownState' => { 'name' => 'shutting-down', 'code' => 32}
+              }
+            else
+              response.status = 400
+              raise(Fog::Errors.status_error(200, 400, response))
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+
+end