fog-aws 0.0.5

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,80 @@
+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