fog 1.26.0 → 1.27.0

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

@@ -1,230 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/basic'
-
-        # Add permissions to a security group
-        #
-        # ==== Parameters
-        # * group_name<~String> - Name of group, optional (can also be specifed as GroupName in options)
-        # * options<~Hash>:
-        #   * 'GroupName'<~String> - Name of security group to modify
-        #   * 'GroupId'<~String> - Id of security group to modify
-        #   * 'SourceSecurityGroupName'<~String> - Name of security group to authorize
-        #   * 'SourceSecurityGroupOwnerId'<~String> - Name of owner to authorize
-        #   or
-        #   * 'CidrIp'<~String> - CIDR range
-        #   * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
-        #   * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
-        #   * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
-        #   or
-        #   * 'IpPermissions'<~Array>:
-        #     * permission<~Hash>:
-        #       * 'FromPort'<~Integer> - Start of port range (or -1 for ICMP wildcard)
-        #       * 'Groups'<~Array>:
-        #         * group<~Hash>:
-        #           * 'GroupName'<~String> - Name of security group to authorize
-        #           * 'UserId'<~String> - Name of owner to authorize
-        #       * 'IpProtocol'<~String> - Ip protocol, must be in ['tcp', 'udp', 'icmp']
-        #       * 'IpRanges'<~Array>:
-        #         * ip_range<~Hash>:
-        #           * 'CidrIp'<~String> - CIDR range
-        #       * 'ToPort'<~Integer> - End of port range (or -1 for ICMP wildcard)
-        #
-        # === 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-AuthorizeSecurityGroupIngress.html]
-        def authorize_security_group_ingress(group_name, options = {})
-          options = Fog::AWS.parse_security_group_options(group_name, options)
-
-          if ip_permissions = options.delete('IpPermissions')
-            options.merge!(indexed_ip_permissions_params(ip_permissions))
-          end
-
-          request({
-            'Action'    => 'AuthorizeSecurityGroupIngress',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::Basic.new
-          }.merge!(options))
-        end
-
-        private
-
-        def indexed_ip_permissions_params(ip_permissions)
-          params = {}
-          ip_permissions.each_with_index do |permission, key_index|
-            key_index += 1
-            params[format('IpPermissions.%d.IpProtocol', key_index)] = permission['IpProtocol']
-            params[format('IpPermissions.%d.FromPort', key_index)] = permission['FromPort']
-            params[format('IpPermissions.%d.ToPort', key_index)] = permission['ToPort']
-            (permission['Groups'] || []).each_with_index do |group, group_index|
-              group_index += 1
-              params[format('IpPermissions.%d.Groups.%d.UserId', key_index, group_index)] = group['UserId']
-              params[format('IpPermissions.%d.Groups.%d.GroupName', key_index, group_index)] = group['GroupName']
-              params[format('IpPermissions.%d.Groups.%d.GroupId', key_index, group_index)] = group['GroupId']
-            end
-            (permission['IpRanges'] || []).each_with_index do |ip_range, range_index|
-              range_index += 1
-              params[format('IpPermissions.%d.IpRanges.%d.CidrIp', key_index, range_index)] = ip_range['CidrIp']
-            end
-          end
-          params.reject {|k, v| v.nil? }
-        end
-      end
-
-      class Mock
-        def authorize_security_group_ingress(group_name, options = {})
-          options = Fog::AWS.parse_security_group_options(group_name, options)
-          if options.key?('GroupName')
-            group_name = options['GroupName']
-          else
-            group_name = self.data[:security_groups].reject { |k,v| v['groupId'] != options['GroupId'] } .keys.first
-          end
-
-          response = Excon::Response.new
-          group = self.data[:security_groups][group_name]
-
-          if group
-            verify_permission_options(options, group['vpcId'] != nil)
-
-            normalized_permissions = normalize_permissions(options)
-
-            normalized_permissions.each do |permission|
-              if matching_group_permission = find_matching_permission(group, permission)
-                if permission['groups'].any? {|pg| matching_group_permission['groups'].include?(pg) }
-                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
-                end
-
-                if permission['ipRanges'].any? {|pr| matching_group_permission['ipRanges'].include?(pr) }
-                  raise Fog::Compute::AWS::Error, "InvalidPermission.Duplicate => The permission '123' has already been authorized in the specified group"
-                end
-              end
-            end
-
-            normalized_permissions.each do |permission|
-              if matching_group_permission = find_matching_permission(group, permission)
-                matching_group_permission['groups'] += permission['groups']
-                matching_group_permission['ipRanges'] += permission['ipRanges']
-              else
-                group['ipPermissions'] << permission
-              end
-            end
-
-            response.status = 200
-            response.body = {
-              'requestId' => Fog::AWS::Mock.request_id,
-              'return'    => true
-            }
-            response
-          else
-            raise Fog::Compute::AWS::NotFound.new("The security group '#{group_name}' does not exist")
-          end
-        end
-
-        private
-
-        def verify_permission_options(options, is_vpc)
-          if options.size <= 1
-            raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
-          end
-          if !is_vpc && options['IpProtocol'] && !['tcp', 'udp', 'icmp'].include?(options['IpProtocol'])
-            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => Unsupported IP protocol \"#{options['IpProtocol']}\"  - supported: [tcp, udp, icmp]")
-          end
-          if !is_vpc && (options['IpProtocol'] && (!options['FromPort'] || !options['ToPort']))
-            raise Fog::Compute::AWS::Error.new("InvalidPermission.Malformed => TCP/UDP port (-1) out of range")
-          end
-          if options.key?('IpPermissions')
-            if !options['IpPermissions'].is_a?(Array) || options['IpPermissions'].empty?
-              raise Fog::Compute::AWS::Error.new("InvalidRequest => The request received was invalid.")
-            end
-            options['IpPermissions'].each {|p| verify_permission_options(p, is_vpc) }
-          end
-        end
-
-        def normalize_permissions(options)
-          normalized_permissions = []
-          if options['SourceSecurityGroupName']
-            group_name = if options['SourceSecurityGroupName'] =~ /default_elb/
-                           "default"
-                         else
-                           options['SourceSecurityGroupName']
-                         end
-            source_group_id=self.data[:security_groups][group_name]['groupId']
-            ['tcp', 'udp'].each do |protocol|
-              normalized_permissions << {
-                'ipProtocol' => protocol,
-                'fromPort' => 1,
-                'toPort' => 65535,
-                'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }],
-                'ipRanges' => []
-              }
-            end
-            normalized_permissions << {
-              'ipProtocol' => 'icmp',
-              'fromPort' => -1,
-              'toPort' => -1,
-              'groups' => [{'groupName' => options['SourceSecurityGroupName'], 'userId' => options['SourceSecurityGroupOwnerId'] || self.data[:owner_id], 'groupId' => source_group_id }],
-              'ipRanges' => []
-            }
-          elsif options['CidrIp']
-            normalized_permissions << {
-              'ipProtocol' => options['IpProtocol'],
-              'fromPort' => Integer(options['FromPort']),
-              'toPort' => Integer(options['ToPort']),
-              'groups' => [],
-              'ipRanges' => [{'cidrIp' => options['CidrIp']}]
-            }
-          elsif options['IpPermissions']
-            options['IpPermissions'].each do |permission|
-              if ['tcp', 'udp', 'icmp'].include?(permission['IpProtocol'])
-                normalized_permissions << {
-                  'ipProtocol' => permission['IpProtocol'],
-                  'fromPort' => Integer(permission['FromPort']),
-                  'toPort' => Integer(permission['ToPort']),
-                  'groups' => (permission['Groups'] || []).map do |authorized_group|
-                    security_group = if group_name = authorized_group['GroupName']
-                                       self.data[:security_groups][group_name] || {}
-                                     elsif group_id = authorized_group['GroupId']
-                                       self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id } || {}
-                                     end
-
-                    {'groupName' => authorized_group['GroupName'] || security_group["groupName"], 'userId' => authorized_group['UserId'] || self.data[:owner_id], 'groupId' => authorized_group["GroupId"] || security_group['groupId']}
-                  end,
-                  'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
-                }
-              else
-                normalized_permissions << {
-                  'ipProtocol' => permission['IpProtocol'],
-                  'groups' => (permission['Groups'] || []).map do |authorized_group|
-                    security_group = if group_name = authorized_group['GroupName']
-                                       self.data[:security_groups][group_name] || {}
-                                     elsif group_id = authorized_group['GroupId']
-                                       self.data[:security_groups].values.find { |sg| sg['groupId'] == group_id } || {}
-                                     end
-
-                    {'groupName' => authorized_group['GroupName'] || security_group["groupName"], 'userId' => authorized_group['UserId'] || self.data[:owner_id], 'groupId' => authorized_group["GroupId"] || security_group['groupId']}
-                  end,
-                  'ipRanges' => (permission['IpRanges'] || []).map {|r| { 'cidrIp' => r['CidrIp'] } }
-                }
-              end
-            end
-          end
-
-          normalized_permissions
-        end
-
-        def find_matching_permission(group, permission)
-          group['ipPermissions'].find {|group_permission|
-            permission['ipProtocol'] == group_permission['ipProtocol'] &&
-            permission['fromPort'] == group_permission['fromPort'] &&
-            permission['toPort'] == group_permission['toPort'] }
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/cancel_spot_instance_requests'
-
-        # Terminate specified spot instance requests
-        #
-        # ==== Parameters
-        # * spot_instance_request_id<~Array> - Ids of instances to terminates
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> id of request
-        #     * 'spotInstanceRequestSet'<~Array>:
-        #       * 'spotInstanceRequestId'<~String> - id of cancelled spot instance
-        #       * 'state'<~String> - state of cancelled spot instance
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CancelSpotInstanceRequests.html]
-        def cancel_spot_instance_requests(spot_instance_request_id)
-          params = Fog::AWS.indexed_param('SpotInstanceRequestId', spot_instance_request_id)
-          request({
-            'Action'    => 'CancelSpotInstanceRequests',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::CancelSpotInstanceRequests.new
-          }.merge!(params))
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/copy_image'
-
-        # Copy an image to a different region
-        #
-        # ==== Parameters
-        # * source_image_id<~String>    - The ID of the AMI to copy
-        # * source_region<~String>      - The name of the AWS region that contains the AMI to be copied
-        # * name<~String>               - The name of the new AMI in the destination region
-        # * description<~String>        - The description to set on the new AMI in the destination region
-        # * client_token<~String>       - Unique, case-sensitive identifier you provide to ensure idempotency of the request
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - id of request
-        #     * 'imageId'<~String> - id of image
-        #
-        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/CommandLineReference/ApiReference-cmd-CopyImage.html]
-        def copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil)
-          request(
-            'Action'          => 'CopyImage',
-            'SourceImageId'   => source_image_id,
-            'SourceRegion'    => source_region,
-            'Name'            => name,
-            'Description'     => description,
-            'ClientToken'     => client_token,
-            :parser           => Fog::Parsers::Compute::AWS::CopyImage.new
-          )
-        end
-      end
-
-      class Mock
-        #
-        # Usage
-        #
-        # AWS[:compute].copy_image("ami-1aad5273", 'us-east-1')
-        #
-
-        def copy_image(source_image_id, source_region, name = nil, description = nil, client_token = nil)
-          response = Excon::Response.new
-          response.status = 200
-          image_id = Fog::AWS::Mock.image_id
-          data = {
-            'imageId'  => image_id,
-          }
-          self.data[:images][image_id] = data
-          response.body = {
-            'requestId' => Fog::AWS::Mock.request_id
-          }.merge!(data)
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/copy_snapshot'
-
-        # Copy a snapshot to a different region
-        #
-        # ==== Parameters
-        # * source_snapshot_id<~String> - Id of snapshot
-        # * source_region<~String>      - Region to move it from
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - id of request
-        #     * 'snapshotId'<~String> - id of snapshot
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CopySnapshot.html]
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
-          request(
-            'Action'          => 'CopySnapshot',
-            'SourceSnapshotId'=> source_snapshot_id,
-            'SourceRegion'    => source_region,
-            'Description'     => description,
-            :parser       => Fog::Parsers::Compute::AWS::CopySnapshot.new
-          )
-        end
-      end
-
-      class Mock
-        #
-        # Usage
-        #
-        # AWS[:compute].copy_snapshot("snap-1db0a957", 'us-east-1')
-        #
-
-        def copy_snapshot(source_snapshot_id, source_region, description = nil)
-          response = Excon::Response.new
-          response.status = 200
-          snapshot_id = Fog::AWS::Mock.snapshot_id
-          data = {
-            'snapshotId'  => snapshot_id,
-          }
-          self.data[:snapshots][snapshot_id] = data
-          response.body = {
-            'requestId' => Fog::AWS::Mock.request_id
-          }.merge!(data)
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-module Fog
-  module Compute
-    class AWS
-      class Real
-        require 'fog/aws/parsers/compute/create_dhcp_options'
-
-        # Creates a set of DHCP options for your VPC
-        #
-        # ==== Parameters
-        # * DhcpConfigurationOptions<~Hash> - hash of key value dhcp options to assign
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'requestId'<~String> - Id of request
-        #
-        # {Amazon API Reference}[http://docs.amazonwebservices.com/AWSEC2/latest/APIReference/ApiReference-query-CreateDhcpOptions.html]
-        def create_dhcp_options(dhcp_configurations = {})
-          params = {}
-          params.merge!(indexed_multidimensional_params(dhcp_configurations))
-          request({
-            'Action'    => 'CreateDhcpOptions',
-            :idempotent => true,
-            :parser     => Fog::Parsers::Compute::AWS::CreateDhcpOptions.new
-          }.merge!(params))
-        end
-        private
-          def indexed_multidimensional_params(multi_params)
-            params = {}
-            multi_params.keys.each_with_index do |key, key_index|
-              key_index += 1
-              params[format('DhcpConfiguration.%d.Key', key_index)] = key
-              [*multi_params[key]].each_with_index do |value, value_index|
-                value_index += 1
-                params[format('DhcpConfiguration.%d.Value.%d', key_index, value_index)] = value
-              end
-            end
-            params
-         end
-       end
-      class Mock
-        def create_dhcp_options(dhcp_configurations = {})
-          params = {}
-          params.merge!(indexed_multidimensional_params(dhcp_configurations))
-          Excon::Response.new.tap do |response|
-            response.status = 200
-            self.data[:dhcp_options].push({
-              'dhcpOptionsId' => Fog::AWS::Mock.dhcp_options_id,
-              'dhcpConfigurationSet'  => {},
-              'tagSet'             => {}
-            })
-            response.body = {
-              'requestId'    => Fog::AWS::Mock.request_id,
-              'dhcpOptionsSet'      => self.data[:dhcp_options]
-            }
-          end
-        end
-        private
-          def indexed_multidimensional_params(multi_params)
-            params = {}
-            multi_params.keys.each_with_index do |key, key_index|
-              key_index += 1
-              params[format('DhcpConfiguration.%d.Key', key_index)] = key
-              [*multi_params[key]].each_with_index do |value, value_index|
-                value_index += 1
-                params[format('DhcpConfiguration.%d.Value.%d', key_index, value_index)] = value
-              end
-            end
-            params
-         end
-      end
-    end
-  end
-end