fog 1.15.0 → 1.16.0

data/lib/fog/aws/parsers/redshift/revoke_cluster_security_group_ingress.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Parsers
+    module Redshift
+      module AWS
+
+        require 'fog/aws/parsers/redshift/cluster_security_group_parser'
+
+        class RevokeClusterSecurityGroupIngress < ClusterSecurityGroupParser
+          # :cluster_security_group
+          
+          def reset
+            super
+            @response = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)            
+            super
+            case name
+            when 'ClusterSecurityGroup'
+              @response['ClusterSecurityGroup'] = @cluster_security_group
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/redshift/update_cluster_parameter_group_parser.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Parsers
+    module Redshift
+      module AWS
+
+        class UpdateClusterParameterGroupParser < Fog::Parsers::Base
+          # :parameter_group_name - (String)
+          # :parameter_group_status - (String)
+          
+          def reset
+            @response = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)            
+            super
+            case name
+            when 'ParameterGroupName', 'ParameterGroupStatus'
+              @response[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/sts/get_session_token.rb

@@ -14,10 +14,8 @@ module Fog
             case name
             when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
               @response[name] = @value.strip
-            when 'Arn', 'FederatedUserId'
+            when 'Arn', 'FederatedUserId', 'PackedPolicySize'
               @response[name] = @value.strip
-            when 'PackedPolicySize'
-              @response[name] = @value
             when 'RequestId'
               @response[name] = @value
             end

data/lib/fog/aws/redshift.rb

@@ -0,0 +1,126 @@
+require 'fog/aws'
+
+module Fog
+  module AWS
+    class Redshift < Fog::Service
+      extend Fog::AWS::CredentialFetcher::ServiceMethods
+      
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent, :use_iam_profile, :aws_session_token, :aws_credentials_expire_at
+
+      request_path 'fog/aws/requests/redshift'
+
+      request :describe_clusters
+      request :describe_cluster_parameter_groups
+      request :describe_cluster_parameters
+      request :describe_cluster_security_groups
+      request :describe_cluster_snapshots
+      request :describe_cluster_subnet_groups
+      request :describe_cluster_versions
+      request :describe_default_cluster_parameters
+      request :describe_events
+      request :describe_orderable_cluster_options
+      request :describe_reserved_node_offerings
+      request :describe_reserved_nodes
+      request :describe_resize
+      request :create_cluster
+      request :create_cluster_parameter_group
+      request :create_cluster_security_group
+      request :create_cluster_snapshot
+      request :create_cluster_subnet_group
+      request :modify_cluster
+      request :modify_cluster_parameter_group
+      request :modify_cluster_subnet_group  
+      request :delete_cluster             
+      request :delete_cluster_parameter_group
+      request :delete_cluster_security_group
+      request :delete_cluster_snapshot
+      request :delete_cluster_subnet_group
+      request :authorize_cluster_security_group_ingress 
+      request :authorize_snapshot_access                 
+      request :copy_cluster_snapshot                     
+      request :purchase_reserved_node_offering           
+      request :reboot_cluster
+      request :reset_cluster_parameter_group            
+      request :restore_from_cluster_snapshot           
+      request :revoke_cluster_security_group_ingress       
+      request :revoke_snapshot_access                    
+
+      class Mock
+
+        def initialize(options={})
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+      class Real
+        include Fog::AWS::CredentialFetcher::ConnectionMethods
+        # Initialize connection to Redshift
+        #
+        # ==== Notes
+        # options parameter must include values for :aws_access_key_id and
+        # :aws_secret_access_key in order to create a connection
+        #
+        # ==== Examples
+        #   ses = SES.new(
+        #    :aws_access_key_id => your_aws_access_key_id,
+        #    :aws_secret_access_key => your_aws_secret_access_key
+        #   )
+        #
+        # ==== Parameters
+        # * options<~Hash> - config arguments for connection.  Defaults to {}.
+        #   * region<~String> - optional region to use. For instance, 'us-east-1' and etc.
+        #
+        # ==== Returns
+        # * Redshift object with connection to AWS.
+
+
+        def initialize(options={})
+
+          @use_iam_profile = options[:use_iam_profile]
+          @region = options[:region] || 'us-east-1'
+          setup_credentials(options)
+
+          @connection_options     = options[:connection_options] || {}
+          @host = options[:host] || "redshift.#{@region}.amazonaws.com"
+          @version = '2012-12-01'
+          @path       = options[:path]        || '/'
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || 443
+          @scheme     = options[:scheme]      || 'https'
+
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
+       end
+
+
+        private
+        def setup_credentials(options)
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @aws_session_token      = options[:aws_session_token]
+          @aws_credentials_expire_at = options[:aws_credentials_expire_at]
+
+          @signer = Fog::AWS::SignatureV4.new( @aws_access_key_id, @aws_secret_access_key,@region,'redshift')
+        end
+
+        def request(params, &block)
+          refresh_credentials_if_expired
+
+          parser = params.delete(:parser)
+          date   = Fog::Time.now
+          params[:headers]['Date'] = date.to_date_header
+          params[:headers]['x-amz-date'] = date.to_iso8601_basic
+
+          params[:headers]['Host'] = @host
+          params[:headers]['x-amz-redshift-version'] = @version
+          params[:headers]['x-amz-security-token'] = @aws_session_token if @aws_session_token
+          params[:headers]['Authorization'] = @signer.sign params, date
+
+          response = @connection.request(params.merge(:parser => parser), &block)
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/auto_scaling/create_auto_scaling_group.rb

@@ -72,16 +72,17 @@ module Fog
           if load_balancer_names = options.delete('LoadBalancerNames')
             options.merge!(AWS.indexed_param('LoadBalancerNames.member.%d', [*load_balancer_names]))
           end
+          
           if tags = options.delete('Tags')
-            tags.each_with_index do |tag, i|
-              tag.each do |key, value|
-                options["Tags.member.#{i+1}.#{key}"] = value unless value.nil?
-              end
+            tags.each_with_index do |(key, value), i|
+              options["Tags.member.#{i+1}.Key"] = key.to_s # turns symbol into string
+              options["Tags.member.#{i+1}.Value"] = value
             end
           end
           if termination_policies = options.delete('TerminationPolicies')
             options.merge!(AWS.indexed_param('TerminationPolicies.member.%d', [*termination_policies]))
           end
+          
           request({
             'Action'                  => 'CreateAutoScalingGroup',
             'AutoScalingGroupName'    => auto_scaling_group_name,

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

@@ -3,7 +3,7 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/parsers/compute/associate_dhcp_options'
+        require 'fog/aws/parsers/compute/basic'
         # 
         #
         # ==== Parameters
@@ -24,7 +24,7 @@ module Fog
             'DhcpOptionsId'        => dhcp_options_id,
             'VpcId'                => vpc_id,
             :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::AttachInternetGateway.new
+            :parser       => Fog::Parsers::Compute::AWS::Basic.new
           )
         end
 

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

@@ -0,0 +1,75 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/associate_route_table'
+        # Associates a subnet with a route table.
+        #
+        # ==== Parameters
+        # * RouteTableId<~String> - The ID of the route table
+        # * SubnetId<~String> - The ID of the subnet
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - The ID of the request
+        #     * 'associationId'<~String> - The route table association ID (needed to disassociate the route table)
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-AssociateRouteTable.html]
+        def associate_route_table(routeTableId, subnetId)
+          request(
+            'Action'       => 'AssociateRouteTable',
+            'RouteTableId' => routeTableId,
+            'SubnetId'     => subnetId,
+            :parser        => Fog::Parsers::Compute::AWS::AssociateRouteTable.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def associate_route_table(routeTableId, subnetId)
+          routetable = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? routeTableId }
+          subnet = self.data[:subnets].find { |subnet| subnet["subnetId"].eql? subnetId }
+
+          if !routetable.nil? && !subnet.nil?
+            response = Excon::Response.new
+            response.status = 200
+            association = add_route_association(routeTableId, subnetId)
+            routetable["associationSet"].push(association)
+            response.body = {
+                'requestId'     => Fog::AWS::Mock.request_id,
+                'associationId' => association['routeTableAssociationId']
+            }
+            response
+          elsif routetable.nil?
+            raise Fog::Compute::AWS::NotFound.new("The routeTable ID '#{routeTableId}' does not exist")
+          else
+            raise Fog::Compute::AWS::NotFound.new("The subnet ID '#{subnetId}' does not exist")
+          end
+
+        end
+
+        private
+
+        def add_route_association(routeTableId, subnetId, main=nil)
+          response = {
+              "routeTableAssociationId" => "rtbassoc-#{Fog::Mock.random_hex(8)}", 
+              "routeTableId" => routeTableId,
+              "subnetId" => nil,
+              "main" => false
+            }
+          if main
+            response['main'] = true
+          else
+            response['subnetId'] = subnetId
+          end
+          response   
+        end
+        
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Fog
     class AWS
       class Real
 
-        require 'fog/aws/parsers/compute/attach_internet_gateway'
+        require 'fog/aws/parsers/compute/basic'
         # Attaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC
         #
         # ==== Parameters
@@ -23,7 +23,7 @@ module Fog
             'InternetGatewayId'    => internet_gateway_id,
             'VpcId'                => vpc_id,
             :idempotent   => true,
-            :parser       => Fog::Parsers::Compute::AWS::AttachInternetGateway.new
+            :parser       => Fog::Parsers::Compute::AWS::Basic.new
           )
         end
 

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

@@ -0,0 +1,89 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/basic'
+
+        # Creates a route in a route table within a VPC.
+        #
+        # ==== Parameters
+        # * RouteTableId<~String> - The ID of the route table for the route.
+        # * 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> - he 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-CreateRoute.html]
+        def create_route(route_table_id, destination_cidr_block, internet_gateway_id=nil, instance_id=nil, network_interface_id=nil)
+          request_vars = {
+            'Action'                => 'CreateRoute',
+            'RouteTableId'          => route_table_id,
+            'DestinationCidrBlock'  => destination_cidr_block,
+            :parser                 => Fog::Parsers::Compute::AWS::Basic.new
+          }
+          if internet_gateway_id
+            request_vars['GatewayId'] = internet_gateway_id
+          elsif instance_id
+            request_vars['InstanceId'] = instance_id
+          elsif network_interface_id
+            request_vars['NetworkInterfaceId'] = network_interface_id         
+          end
+          request(request_vars)
+        end
+      end
+
+      class Mock
+
+        def create_route(route_table_id, destination_cidr_block, internet_gateway_id=nil, instance_id=nil, network_interface_id=nil)
+          instance_owner_id = nil
+          route_table = self.data[:route_tables].find { |routetable| routetable["routeTableId"].eql? route_table_id }
+          if !route_table.nil? && destination_cidr_block
+            if !internet_gateway_id.nil? || !instance_id.nil? || !network_interface_id.nil?
+              if !internet_gateway_id.nil? && self.internet_gateways.all('internet-gateway-id'=>internet_gateway_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The gateway ID '#{internet_gateway_id}' does not exist")
+              elsif !instance_id.nil? && self.servers.all('instance-id'=>instance_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The instance ID '#{instance_id}' does not exist")
+              elsif !network_interface_id.nil? && self.network_interfaces.all('networkInterfaceId'=>network_interface_id).first.nil?
+                raise Fog::Compute::AWS::NotFound.new("The networkInterface ID '#{network_interface_id}' 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} already exists."
+              else   
+                response = Excon::Response.new           
+                route_table['routeSet'].push({
+                  "destinationCidrBlock" => destination_cidr_block,
+                  "gatewayId" => internet_gateway_id,
+                  "instanceId"=>instance_id, 
+                  "instanceOwnerId"=>instance_owner_id, 
+                  "networkInterfaceId"=>network_interface_id, 
+                  "state" => "pending",
+                  "origin" => "CreateRoute"
+                })
+                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

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

@@ -0,0 +1,70 @@
+module Fog
+  module Compute
+    class AWS
+      class Real
+
+        require 'fog/aws/parsers/compute/create_route_table'
+
+        # Creates a route table for the specified VPC.
+        #
+        # ==== Parameters
+        # * VpcId<~String> - The ID of the VPC.
+        #
+        # === Returns
+        # * response<~Excon::Response>:
+        # * body<~Hash>:
+        # * 'requestId'<~String> - Id of the request
+        # * 'routeTable'<~Array> - Information about the newly created route table
+        # *   'routeTableId'<~String>
+        # *   'vpcId'<~String>
+        # *   'routeSet'<~Array>
+        # *     'item'<~Array>
+        # *       'destinationCidrBlock'<~String> - The CIDR address block used for the destination match.
+        # *       'gatewayId'<~String> - The ID of an Internet gateway attached to your VPC.
+        # *       'state'<~String> - The state of the route. ['blackhole', 'available']
+        #
+        # {Amazon API Reference}[http://docs.aws.amazon.com/AWSEC2/latest/APIReference/ApiReference-query-CreateRouteTable.html]
+        def create_route_table(vpc_id)
+          request({
+            'Action' => 'CreateRouteTable',
+            'VpcId' => vpc_id,
+            :parser => Fog::Parsers::Compute::AWS::CreateRouteTable.new
+          })
+        end
+      end
+      
+      class Mock
+        def create_route_table(vpc_id)
+          response = Excon::Response.new
+          vpc = self.data[:vpcs].find { |vpc| vpc["vpcId"].eql? vpc_id }
+          unless vpc.nil?
+            response.status = 200
+            route_table = {
+              'routeTableId' => "rtb-#{Fog::Mock.random_hex(8)}",
+              'vpcId' => vpc["vpcId"],
+              'routeSet' => [{
+                "destinationCidrBlock" => vpc["cidrBlock"],
+                "gatewayId" => "local",
+                "instanceId"=>nil, 
+                "instanceOwnerId"=>nil, 
+                "networkInterfaceId"=>nil, 
+                "state" => "pending",
+                "origin" => "CreateRouteTable"
+              }],
+              'associationSet' => [],
+              'tagSet' => {}
+            }
+            self.data[:route_tables].push(route_table)
+            response.body = {
+              'requestId'=> Fog::AWS::Mock.request_id,
+              'routeTable' => [route_table]
+            }
+            response
+          else
+            raise Fog::Compute::AWS::NotFound.new("The vpc ID '#{vpc_id}' does not exist")
+          end 
+        end
+      end
+    end
+  end
+end