fog 1.26.0 → 1.27.0

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

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

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

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

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

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

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