tecnh-fog 0.2.23.vpc

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

@@ -0,0 +1,86 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/describe_volumes'
+
+        # Describe all or specified volumes.
+        #
+        # ==== Parameters
+        # * volume_id<~Array> - List of volumes to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'volumeSet'<~Array>:
+        #       * 'availabilityZone'<~String> - Availability zone for volume
+        #       * 'createTime'<~Time> - Timestamp for creation
+        #       * 'size'<~Integer> - Size in GiBs for volume
+        #       * 'snapshotId'<~String> - Snapshot volume was created from, if any
+        #       * 'status'<~String> - State of volume
+        #       * 'volumeId'<~String> - Reference to volume
+        #       * 'attachmentSet'<~Array>:
+        #         * 'attachmentTime'<~Time> - Timestamp for attachment
+        #         * 'device'<~String> - How value is exposed to instance
+        #         * 'instanceId'<~String> - Reference to attached instance
+        #         * 'status'<~String> - Attachment state
+        #         * 'volumeId'<~String> - Reference to volume
+        def describe_volumes(volume_id = [])
+          params = AWS.indexed_param('VolumeId', volume_id)
+          request({
+            'Action'    => 'DescribeVolumes',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DescribeVolumes.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_volumes(volume_id = [])
+          response = Excon::Response.new
+          volume_id = [*volume_id]
+          if volume_id != []
+            volume_set = @data[:volumes].reject {|key,value| !volume_id.include?(key)}.values
+          else
+            volume_set = @data[:volumes].values
+          end
+
+          if volume_id.length == 0 || volume_id.length == volume_set.length
+            volume_set.each do |volume|
+              case volume['status']
+              when 'attaching'
+                if Time.now - volume['attachmentSet'].first['attachTime'] > Fog::Mock.delay
+                  volume['attachmentSet'].first['status'] = 'in-use'
+                  volume['status'] = 'in-use'
+                end
+              when 'creating'
+                if Time.now - volume['createTime'] > Fog::Mock.delay
+                  volume['status'] = 'available'
+                end
+              when 'deleting'
+                if Time.now - @data[:deleted_at][volume['volumeId']] > Fog::Mock.delay
+                  @data[:deleted_at].delete(volume['volumeId'])
+                  @data[:volumes].delete(volume['volumeId'])
+                end
+              end
+            end
+
+            volume_set = volume_set.reject {|volume| !@data[:volumes][volume['volumeId']]}
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'volumeSet' => volume_set
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The volume #{volume_id.inspect} does not exist.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/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
+        def detach_volume(volume_id, options = {})
+          request({
+            'Action'    => 'DetachVolume',
+            'VolumeId'  => volume_id,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::DetachVolume.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def detach_volume(volume_id, options = {})
+          response = Excon::Response.new
+          response.status = 200
+          if (volume = @data[:volumes][volume_id]) && !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
+            raise Fog::AWS::EC2::NotFound.new("The volume '#{volume_id}' does not exist.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        # Disassociate an elastic IP address from its instance (if any)
+        #
+        # ==== Parameters
+        # * public_ip<~String> - Public ip to assign to instance
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'return'<~Boolean> - success?
+        def disassociate_address(public_ip)
+          request(
+            'Action'    => 'DisassociateAddress',
+            'PublicIp'  => public_ip,
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def disassociate_address(public_ip)
+          response = Excon::Response.new
+          response.status = 200
+          if address = @data[:addresses][public_ip]
+            instance_id = address['instanceId']
+            instance = @data[:instances][instance_id]
+            instance['ipAddress']         = instance['originalIpAddress']
+            instance['dnsName']           = Fog::AWS::Mock.dns_name_for(instance['ipAddress'])
+            address['instanceId'] = nil
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::EC2::Error.new("AuthFailure => The address '#{public_ip}' does not belong to you.")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/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
+        def get_console_output(instance_id)
+          request(
+            'Action'      => 'GetConsoleOutput',
+            'InstanceId'  => instance_id,
+            :idempotent   => true,
+            :parser       => Fog::Parsers::AWS::EC2::GetConsoleOutput.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def get_console_output(instance_id)
+          response = Excon::Response.new
+          if instance = @data[:instances][instance_id]
+            response.status = 200
+            response.body = {
+              'instanceId'    => instance_id,
+              'output'        => nil,
+              'requestId'     => Fog::AWS::Mock.request_id,
+              'timestamp'     => Time.now
+            }
+            response
+          else;
+            raise Fog::AWS::EC2::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        # Modify image attributes
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of machine image to modify
+        # * attribute<~String> - Attribute to modify, in ['launchPermission', 'productCodes']
+        # * operation_type<~String> - Operation to perform on attribute, in ['add', 'remove']
+        #
+        def modify_image_attributes(image_id, attribute, operation_type, options = {})
+          params = {}
+          params.merge!(AWS.indexed_param('UserId', options['UserId']))
+          params.merge!(AWS.indexed_param('UserGroup', options['UserGroup']))
+          params.merge!(AWS.indexed_param('ProductCode', options['ProductCode']))
+          request({
+            'Action'        => 'ModifyImageAttribute',
+            'Attribute'     => attribute,
+            'ImageId'       => image_id,
+            'OperationType' => operation_type,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::AWS::EC2::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def modify_image_attributes(image_id, attribute, operation_type, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        # Modify snapshot attributes
+        #
+        # ==== Parameters
+        # * snapshot_id<~String> - Id of snapshot to modify
+        # * attribute<~String> - Attribute to modify, in ['createVolumePermission']
+        # * operation_type<~String> - Operation to perform on attribute, in ['add', 'remove']
+        #
+        def modify_snapshot_attribute(snapshot_id, attribute, operation_type, options = {})
+          params = {}
+          params.merge!(AWS.indexed_param('UserId', options['UserId'], 1))
+          params.merge!(AWS.indexed_param('UserGroup', options['UserGroup'], 1))
+          request({
+            'Action'        => 'ModifySnapshotAttribute',
+            'Attribute'     => attribute,
+            'SnapshotId'    => snapshot_id,
+            'OperationType' => operation_type,
+            :idempotent     => true,
+            :parser         => Fog::Parsers::AWS::EC2::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def modify_snapshot_attribute(snapshot_id, attribute, operation_type, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        # 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?
+        def reboot_instances(instance_id = [])
+          params = AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'RebootInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::EC2::Basic.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def reboot_instances(instance_id = [])
+          response = Excon::Response.new
+          instance_id = [*instance_id]
+          if (@data[:instances].keys & instance_id).length == instance_id.length
+            for instance_id in instance_id
+              @data[:instances][instance_id]['status'] = 'rebooting'
+            end
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'return'    => true
+            }
+            response
+          else
+            raise Fog::AWS::EC2::NotFound.new("The instance ID #{instance_id.inspect} does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Fog
+  module AWS
+    module EC2
+      class Real
+
+        require 'fog/aws/parsers/ec2/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
+
+        def register_image(name, description, location, block_devices=[], options={})
+          common_options = {
+            'Action'      => 'RegisterImage',
+            'Name'        => name,
+            'Description' => description,
+            :parser       => Fog::Parsers::AWS::EC2::RegisterImage.new
+          }
+
+          # This determines if we are doing a snapshot or a S3 backed AMI.
+          if(location =~ /^\/dev\/sd[a-p]\d{0,2}$/)
+            common_options['RootDeviceName'] = location
+          else
+            common_options['ImageLocation'] = location
+          end
+
+          bdi = 0
+          block_devices.each do |bd|
+            bdi += 1
+            ["DeviceName","VirtualName"].each do |n|
+              common_options["BlockDeviceMapping.#{bdi}.#{n}"] = bd["#{n}"] if bd["#{n}"]
+            end
+            ["SnapshotId","VolumeSize","NoDevice","DeleteOnTermination"].each do |n|
+              common_options["BlockDeviceMapping.#{bdi}.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={})
+          response = Excon::Response.new
+          if !name.empty?
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => Fog::AWS::Mock.image_id
+            }
+            response
+          else
+            message = 'MissingParameter => '
+            if name.empty?
+              message << 'The request must contain the parameter name'
+            end
+            raise Fog::AWS::EC2::Error.new(message)
+          end
+        end
+
+      end
+    end
+  end
+end