fog-aws 0.0.5

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

@@ -0,0 +1,91 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_image'
+
+        # Create a bootable EBS volume AMI
+        #
+        # ==== Parameters
+        # * instance_id<~String> - Instance used to create image.
+        # * name<~Name> - Name to give image.
+        # * description<~Name> - Description of image.
+        # * no_reboot<~Boolean> - Optional, whether or not to reboot the image when making the snapshot
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'imageId'<~String> - The ID of the created AMI.
+        #     * 'requestId'<~String> - Id of request.
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateImage.html]
+        def create_image(instance_id, name, description, no_reboot = false, options={})
+          params = {}
+          block_device_mappings = options[:block_device_mappings] ||  []
+
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.DeviceName', block_device_mappings.map{|mapping| mapping['DeviceName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.NoDevice', block_device_mappings.map{|mapping| mapping['NoDevice']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.VirtualName', block_device_mappings.map{|mapping| mapping['VirtualName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.SnapshotId', block_device_mappings.map{|mapping| mapping['Ebs.SnapshotId']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.DeleteOnTermination', block_device_mappings.map{|mapping| mapping['Ebs.DeleteOnTermination']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.VolumeType', block_device_mappings.map{|mapping| mapping['Ebs.VolumeType']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Encrypted', block_device_mappings.map{|mapping| mapping['Ebs.Encrypted']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Iops', block_device_mappings.map{|mapping| mapping['Ebs.Iops']})
+          params.reject!{|k,v| v.nil?}
+
+          request({
+            'Action'            => 'CreateImage',
+            'InstanceId'        => instance_id,
+            'Name'              => name,
+            'Description'       => description,
+            'NoReboot'          => no_reboot.to_s,
+            :parser             => Fog::Parsers::Compute::AWS::CreateImage.new
+          }.merge!(params))
+        end
+      end
+
+      class Mock
+        # Usage
+        #
+        # Fog::AWS[:compute].create_image("i-ac65ee8c", "test", "something")
+        #
+
+        def create_image(instance_id, name, description, no_reboot = false, options = {})
+          params = {}
+          block_device_mappings = options[:block_device_mappings] || []
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.DeviceName', block_device_mappings.map{|mapping| mapping['DeviceName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.NoDevice', block_device_mappings.map{|mapping| mapping['NoDevice']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.VirtualName', block_device_mappings.map{|mapping| mapping['VirtualName']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.SnapshotId', block_device_mappings.map{|mapping| mapping['Ebs.SnapshotId']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.DeleteOnTermination', block_device_mappings.map{|mapping| mapping['Ebs.DeleteOnTermination']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.VolumeType', block_device_mappings.map{|mapping| mapping['Ebs.VolumeType']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Encrypted', block_device_mappings.map{|mapping| mapping['Ebs.Encrypted']})
+          params.merge!Fog::AWS.indexed_param('BlockDeviceMapping.%d.Ebs.Iops', block_device_mappings.map{|mapping| mapping['Ebs.Iops']})
+          params.reject!{|k,v| v.nil?}
+
+          reserved_ebs_root_device  = '/dev/sda1'
+          block_devices = options.delete(:block_device_mappings) || []
+          register_image_response = register_image(name, description, reserved_ebs_root_device, block_devices, options)
+
+          response = Excon::Response.new
+          if instance_id && !name.empty?
+            response.status = 200
+            response.body = {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'imageId' => register_image_response.body['imageId']
+            }
+          else
+            response.status = 400
+            response.body = {
+              'Code' => 'InvalidParameterValue'
+            }
+            if name.empty?
+              response.body['Message'] = "Invalid value '' for name. Must be specified."
+            end
+          end
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_internet_gateway'
+
+        # Creates an InternetGateway
+        #
+        # ==== Parameters
+        # (none)
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of request
+        # * 'internetGateway'<~Array>:
+        # *   'attachmentSet'<~Array>: 	A list of VPCs attached to the Internet gateway
+        # *     'vpcId'<~String> - The ID of the VPC the Internet gateway is attached to.
+        # *     'state'<~String> - The current state of the attachment.
+        # *   'tagSet'<~Array>: Tags assigned to the resource.
+        # *     'key'<~String> - Tag's key
+        # *     'value'<~String> - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-ItemType-InternetGatewayAttachmentType.html]
+        def create_internet_gateway()
+          request({
+            'Action'     => 'CreateInternetGateway',
+            :parser      => Fog::Parsers::Compute::AWS::CreateInternetGateway.new
+          })
+        end
+      end
+
+      class Mock
+        def create_internet_gateway()
+          gateway_id = Fog::AWS::Mock.internet_gateway_id
+        self.data[:internet_gateways][gateway_id] = {
+          'internetGatewayId' => gateway_id,
+          'attachmentSet'     => {},
+          'tagSet'            => {}
+        }
+         Excon::Response.new(
+            :status => 200,
+            :body   => {
+              'requestId' => Fog::AWS::Mock.request_id,
+              'internetGatewaySet' => [self.data[:internet_gateways][gateway_id]]
+            }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_key_pair'
+
+        # Create a new key pair
+        #
+        # ==== Parameters
+        # * key_name<~String> - Unique name for key pair.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'keyFingerprint'<~String> - SHA-1 digest of DER encoded private key
+        #     * 'keyMaterial'<~String> - Unencrypted encoded PEM private key
+        #     * 'keyName'<~String> - Name of key
+        #     * 'requestId'<~String> - Id of request
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateKeyPair.html]
+        def create_key_pair(key_name)
+          request(
+            'Action'  => 'CreateKeyPair',
+            'KeyName' => key_name,
+            :parser   => Fog::Parsers::Compute::AWS::CreateKeyPair.new
+          )
+        end
+      end
+
+      class Mock
+        def create_key_pair(key_name)
+          response = Excon::Response.new
+          unless self.data[:key_pairs][key_name]
+            response.status = 200
+            data = {
+              'keyFingerprint'  => Fog::AWS::Mock.key_fingerprint,
+              'keyMaterial'     => Fog::AWS::Mock.key_material,
+              '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/create_network_acl.rb

@@ -0,0 +1,105 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_network_acl'
+
+        # Creates a network ACL
+        #
+        # ==== Parameters
+        # * vpcId<~String> - The ID of the VPC to create this network ACL under
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String>                   - Id of request
+        # * 'networkAcl'<~Array>:                  - The network ACL
+        # *   'networkAclId'<~String>              - The ID of the network ACL
+        # *   'vpcId'<~String>                     - The ID of the VPC for the network ACL
+        # *   'default'<~Boolean>                  - Indicates whether this is the default network ACL for the VPC
+        # *   'entrySet'<~Array>:                  - A list of entries (rules) in the network ACL
+        # *     'ruleNumber'<~Integer>             - The rule number for the entry. ACL entries are processed in ascending order by rule number
+        # *     'protocol'<~Integer>               - The protocol. A value of -1 means all protocols
+        # *     'ruleAction'<~String>              - Indicates whether to allow or deny the traffic that matches the rule
+        # *     'egress'<~Boolean>                 - Indicates whether the rule is an egress rule (applied to traffic leaving the subnet)
+        # *     'cidrBlock'<~String>               - The network range to allow or deny, in CIDR notation
+        # *     'icmpTypeCode'<~Hash>              - ICMP protocol: The ICMP type and code
+        # *       'code'<~Integer>                 - The ICMP code. A value of -1 means all codes for the specified ICMP type
+        # *       'type'<~Integer>                 - The ICMP type. A value of -1 means all types
+        # *     'portRange'<~Hash>                 - TCP or UDP protocols: The range of ports the rule applies to
+        # *       'from'<~Integer>                 - The first port in the range
+        # *       'to'<~Integer>                   - The last port in the range
+        # *   'associationSet'<~Array>:            - A list of associations between the network ACL and subnets
+        # *     'networkAclAssociationId'<~String> - The ID of the association
+        # *     'networkAclId'<~String>            - The ID of the network ACL
+        # *     'subnetId'<~String>                - The ID of the subnet
+        # *   'tagSet'<~Array>:                    - Tags assigned to the resource.
+        # *     'key'<~String>                     - Tag's key
+        # *     'value'<~String>                   - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-CreateNetworkAcl.html]
+        def create_network_acl(vpcId, options = {})
+          request({
+            'Action' => 'CreateNetworkAcl',
+            'VpcId'  => vpcId,
+            :parser  => Fog::Parsers::Compute::AWS::CreateNetworkAcl.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def create_network_acl(vpcId, options = {})
+          response = Excon::Response.new
+          if vpcId
+            id = Fog::AWS::Mock.network_acl_id
+
+            unless self.data[:vpcs].find { |s| s['vpcId'] == vpcId }
+              raise Fog::Compute::AWS::Error.new("Unknown VPC '#{vpcId}' specified")
+            end
+
+            data = {
+              'networkAclId'   => id,
+              'vpcId'          => vpcId,
+              'default'        => false,
+              'entrySet'       => [
+                {
+                  'icmpTypeCode' => {},
+                  'portRange'    => {},
+                  'ruleNumber'   => 32767,
+                  'protocol'     => -1,
+                  'ruleAction'   => "deny",
+                  'egress'       => true,
+                  'cidrBlock'    => "0.0.0.0/0",
+                },
+                {
+                  'icmpTypeCode' => {},
+                  'portRange'    => {},
+                  'ruleNumber'   => 32767,
+                  'protocol'     => -1,
+                  'ruleAction'   => "deny",
+                  'egress'       => false,
+                  'cidrBlock'    => "0.0.0.0/0",
+                },
+              ],
+              'associationSet' => [],
+              'tagSet'         => {}
+            }
+
+            self.data[:network_acls][id] = data
+            response.body = {
+              'requestId'  => Fog::AWS::Mock.request_id,
+              'networkAcl' => data
+            }
+          else
+            response.status = 400
+            response.body = {
+              'Code'    => 'InvalidParameterValue',
+              'Message' => "Invalid value '' for subnetId"
+            }
+          end
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/basic'
+
+        # Creates a Network ACL entry
+        #
+        # ==== 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-CreateNetworkAclEntry.html]
+        def create_network_acl_entry(network_acl_id, rule_number, protocol, rule_action, cidr_block, egress, options = {})
+          request({
+            'Action'       => 'CreateNetworkAclEntry',
+            '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 create_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]
+
+            if self.data[:network_acls][network_acl_id]['entrySet'].find { |r| r['ruleNumber'] == rule_number && r['egress'] == egress }
+              raise Fog::Compute::AWS::Error.new("Already a rule with that number")
+            end
+
+            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/create_network_interface.rb

@@ -0,0 +1,134 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+        require 'fog/aws/parsers/compute/create_network_interface'
+
+        # Creates a network interface
+        #
+        # ==== Parameters
+        # * subnetId<~String> - The ID of the subnet to associate with the network interface
+        # * options<~Hash>:
+        #   * PrivateIpAddress<~String> - The private IP address of the network interface
+        #   * Description<~String>      - The description of the network interface
+        #   * GroupSet<~Array>          - The security group IDs for use by the network interface
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String>          - Id of request
+        # * 'networkInterface'<~Hash>     - The created network interface
+        # *   'networkInterfaceId'<~String> - The ID of the network interface
+        # *   'subnetId'<~String>           - The ID of the subnet
+        # *   'vpcId'<~String>              - The ID of the VPC
+        # *   'availabilityZone'<~String>   - The availability zone
+        # *   'description'<~String>        - The description
+        # *   'ownerId'<~String>            - The ID of the person who created the interface
+        # *   'requesterId'<~String>        - The ID ot teh entity requesting this interface
+        # *   'requesterManaged'<~String>   -
+        # *   'status'<~String>             - "available" or "in-use"
+        # *   'macAddress'<~String>         -
+        # *   'privateIpAddress'<~String>   - IP address of the interface within the subnet
+        # *   'privateDnsName'<~String>     - The private DNS name
+        # *   'sourceDestCheck'<~Boolean>   - Flag indicating whether traffic to or from the instance is validated
+        # *   'groupSet'<~Hash>             - Associated security groups
+        # *     'key'<~String>              - ID of associated group
+        # *     'value'<~String>            - Name of associated group
+        # *   'attachment'<~Hash>:          - Describes the way this nic is attached
+        # *     'attachmentID'<~String>
+        # *     'instanceID'<~String>
+        # *   'association'<~Hash>:         - Describes an eventual instance association
+        # *     'attachmentID'<~String>     - ID of the network interface attachment
+        # *     'instanceID'<~String>       - ID of the instance attached to the network interface
+        # *     'publicIp'<~String>         - Address of the Elastic IP address bound to the network interface
+        # *     'ipOwnerId'<~String>        - ID of the Elastic IP address owner
+        # *   'tagSet'<~Array>:             - Tags assigned to the resource.
+        # *     'key'<~String>              - Tag's key
+        # *     'value'<~String>            - Tag's value
+        #
+        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/2012-03-01/APIReference/ApiReference-query-CreateNetworkInterface.html]
+        def create_network_interface(subnetId, options = {})
+          if security_groups = options.delete('GroupSet')
+            options.merge!(Fog::AWS.indexed_param('SecurityGroupId', [*security_groups]))
+          end
+          request({
+            'Action'     => 'CreateNetworkInterface',
+            'SubnetId'   => subnetId,
+            :parser      => Fog::Parsers::Compute::AWS::CreateNetworkInterface.new
+          }.merge!(options))
+        end
+      end
+
+      class Mock
+        def create_network_interface(subnetId, options = {})
+          response = Excon::Response.new
+          if subnetId
+            subnet = self.data[:subnets].find{ |s| s['subnetId'] == subnetId }
+            if subnet.nil?
+              raise Fog::Compute::AWS::Error.new("Unknown subnet '#{subnetId}' specified")
+            else
+              id = Fog::AWS::Mock.network_interface_id
+              cidr_block = IPAddress.parse(subnet['cidrBlock'])
+
+              groups = {}
+              if options['GroupSet']
+                options['GroupSet'].each do |group_id|
+                  group_obj = self.data[:security_groups].select { |k,v| v['groupId'] == group_id }.first
+                  if group_obj.nil?
+                    raise Fog::Compute::AWS::Error.new("Unknown security group '#{group_id}' specified")
+                  end
+                  groups[group_id] = group_obj
+                end
+              end
+
+              if options['PrivateIpAddress'].nil?
+                # Here we try to act like a DHCP server and pick the first
+                # available IP (not including the first in the cidr block,
+                # which is typically reserved for the gateway).
+                cidr_block.each_host do |p_ip|
+                  unless self.data[:network_interfaces].map{ |ni, ni_conf| ni_conf['privateIpAddress'] }.include?p_ip.to_s ||
+                    cidr_block.first == p_ip
+                    options['PrivateIpAddress'] = p_ip.to_s
+                    break
+                  end
+                end
+              elsif self.data[:network_interfaces].map{ |ni,ni_conf| ni_conf['privateIpAddress'] }.include?options['PrivateIpAddress']
+                raise Fog::Compute::AWS::Error.new('InUse => The specified address is already in use.')
+              end
+
+              data = {
+                'networkInterfaceId' => id,
+                'subnetId'           => subnetId,
+                'vpcId'              => 'mock-vpc-id',
+                'availabilityZone'   => 'mock-zone',
+                'description'        => options['Description'],
+                'ownerId'            => '',
+                'requesterManaged'   => 'false',
+                'status'             => 'available',
+                'macAddress'         => '00:11:22:33:44:55',
+                'privateIpAddress'   => options['PrivateIpAddress'],
+                'sourceDestCheck'    => true,
+                'groupSet'           => groups,
+                'attachment'         => {},
+                'association'        => {},
+                'tagSet'             => {}
+              }
+              self.data[:network_interfaces][id] = data
+              response.body = {
+                'requestId'        => Fog::AWS::Mock.request_id,
+                'networkInterface' => data
+              }
+              response
+            end
+          else
+            response.status = 400
+            response.body = {
+              'Code'    => 'InvalidParameterValue',
+              'Message' => "Invalid value '' for subnetId"
+            }
+          end
+        end
+      end
+    end
+  end
+end