fog 1.26.0 → 1.27.0

data/lib/fog/aws/parsers/storage/get_request_payment.rb

@@ -1,16 +0,0 @@
-module Fog
-  module Parsers
-    module Storage
-      module AWS
-        class GetRequestPayment < Fog::Parsers::Base
-          def end_element(name)
-            case name
-            when 'Payer'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/parsers/storage/get_service.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Parsers
-    module Storage
-      module AWS
-        class GetService < Fog::Parsers::Base
-          def reset
-            @bucket = {}
-            @response = { 'Owner' => {}, 'Buckets' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'Bucket'
-              @response['Buckets'] << @bucket
-              @bucket = {}
-            when 'CreationDate'
-              @bucket['CreationDate'] = Time.parse(value)
-            when 'DisplayName', 'ID'
-              @response['Owner'][name] = value
-            when 'Name'
-              @bucket[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/parsers/storage/initiate_multipart_upload.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Parsers
-    module Storage
-      module AWS
-        class InitiateMultipartUpload < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'Bucket', 'Key', 'UploadId'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/parsers/storage/list_multipart_uploads.rb

@@ -1,52 +0,0 @@
-module Fog
-  module Parsers
-    module Storage
-      module AWS
-        class ListMultipartUploads < Fog::Parsers::Base
-          def reset
-            @upload = { 'Initiator' => {}, 'Owner' => {} }
-            @response = { 'Upload' => [] }
-          end
-
-          def start_element(name, attrs = [])
-            super
-            case name
-            when 'Initiator'
-              @in_initiator = true
-            when 'Owner'
-              @in_owner = true
-            end
-          end
-
-          def end_element(name)
-            case name
-            when 'Bucket', 'KeyMarker', 'NextKeyMarker', 'NextUploadIdMarker', 'UploadIdMarker'
-              @response[name] = value
-            when 'DisplayName', 'ID'
-              if @in_initiator
-                @upload['Initiator'][name] = value
-              elsif @in_owner
-                @upload['Owner'][name] = value
-              end
-            when 'Initiated'
-              @upload[name] = Time.parse(value)
-            when 'Initiator'
-              @in_initiator = false
-            when 'IsTruncated'
-              @response[name] = value == 'true'
-            when 'Key', 'StorageClass', 'UploadId'
-              @upload[name] = value
-            when 'MaxUploads'
-              @response[name] = value.to_i
-            when 'Owner'
-              @in_owner = false
-            when 'Upload'
-              @response['Upload'] << @upload
-              @upload = { 'Initiator' => {}, 'Owner' => {} }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/parsers/storage/list_parts.rb

@@ -1,36 +0,0 @@
-module Fog
-  module Parsers
-    module Storage
-      module AWS
-        class ListParts < Fog::Parsers::Base
-          def reset
-            @part = {}
-            @response = { 'Initiator' => {}, 'Part' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'Bucket', 'Key', 'NextPartNumberMarker', 'PartNumberMarker', 'StorageClass', 'UploadId'
-              @response[name] = value
-            when 'DisplayName', 'ID'
-              @response['Initiator'][name] = value
-            when 'ETag'
-              @part[name] = value
-            when 'IsTruncated'
-              @response[name] = value == 'true'
-            when 'LastModified'
-              @part[name] = Time.parse(value)
-            when 'MaxParts'
-              @response[name] = value.to_i
-            when 'Part'
-              @response['Part'] << @part
-              @part = {}
-            when 'PartNumber', 'Size'
-              @part[name] = value.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Fog
-  module Parsers
-    module AWS
-      module STS
-        class AssumeRole < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
-              @response[name] = @value.strip
-            when 'Arn', 'AssumedRoleId'
-              @response[name] = @value.strip
-            when 'PackedPolicySize'
-              @response[name] = @value
-            when 'RequestId'
-              @response[name] = @value
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Fog
-  module Parsers
-    module AWS
-      module STS
-        class AssumeRoleWithSAML < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
-              @response[name] = @value.strip
-            when 'Arn', 'AssumedRoleId'
-              @response[name] = @value.strip
-            when 'PackedPolicySize'
-              @response[name] = @value
-            when 'RequestId'
-              @response[name] = @value
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-module Fog
-  module Parsers
-    module AWS
-      module STS
-        class GetSessionToken < Fog::Parsers::Base
-					# http://docs.amazonwebservices.com/IAM/latest/UserGuide/index.html?CreatingFedTokens.html
-
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'SessionToken', 'SecretAccessKey', 'Expiration', 'AccessKeyId'
-              @response[name] = @value.strip
-            when 'Arn', 'FederatedUserId', 'PackedPolicySize'
-              @response[name] = @value.strip
-            when 'RequestId'
-              @response[name] = @value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/aws/rds.rb

@@ -1,258 +0,0 @@
-require 'fog/aws/core'
-
-module Fog
-  module AWS
-    class RDS < Fog::Service
-      extend Fog::AWS::CredentialFetcher::ServiceMethods
-
-      class IdentifierTaken < Fog::Errors::Error; end
-
-      class AuthorizationAlreadyExists < Fog::Errors::Error; end
-
-      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, :version, :instrumentor, :instrumentor_name
-
-      request_path 'fog/aws/requests/rds'
-      request :describe_events
-      request :create_db_instance
-      request :modify_db_instance
-      request :describe_db_instances
-      request :delete_db_instance
-      request :reboot_db_instance
-      request :create_db_instance_read_replica
-      request :describe_db_engine_versions
-      request :describe_db_reserved_instances
-
-      request :add_tags_to_resource
-      request :list_tags_for_resource
-      request :remove_tags_from_resource
-
-      request :describe_db_snapshots
-      request :create_db_snapshot
-      request :delete_db_snapshot
-
-      request :create_db_parameter_group
-      request :delete_db_parameter_group
-      request :modify_db_parameter_group
-      request :describe_db_parameter_groups
-
-      request :describe_db_security_groups
-      request :create_db_security_group
-      request :delete_db_security_group
-      request :authorize_db_security_group_ingress
-      request :revoke_db_security_group_ingress
-
-      request :describe_db_parameters
-
-      request :restore_db_instance_from_db_snapshot
-      request :restore_db_instance_to_point_in_time
-
-      request :create_db_subnet_group
-      request :describe_db_subnet_groups
-      request :delete_db_subnet_group
-      # TODO: :modify_db_subnet_group
-
-      request :describe_orderable_db_instance_options
-
-      request :describe_db_log_files
-      request :download_db_logfile_portion
-
-      request :promote_read_replica
-
-      model_path 'fog/aws/models/rds'
-      model       :server
-      collection  :servers
-
-      model       :snapshot
-      collection  :snapshots
-
-      model       :parameter_group
-      collection  :parameter_groups
-
-      model       :parameter
-      collection  :parameters
-
-      model       :security_group
-      collection  :security_groups
-
-      model       :subnet_group
-      collection  :subnet_groups
-
-      model       :instance_option
-      collection  :instance_options
-
-      model       :log_file
-      collection  :log_files
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, region|
-            hash[region] = Hash.new do |region_hash, key|
-              region_hash[key] = {
-                :servers => {},
-                :security_groups => {},
-                :subnet_groups => {},
-                :snapshots => {},
-                :parameter_groups => {"default.mysql5.1" => { "DBParameterGroupFamily"=>"mysql5.1",
-                                                              "Description"=>"Default parameter group for mysql5.1",
-                                                              "DBParameterGroupName"=>"default.mysql5.1"
-                                                            },
-                                      "default.mysql5.5" => {"DBParameterGroupFamily"=>"mysql5.5",
-                                                            "Description"=>"Default parameter group for mysql5.5",
-                                                            "DBParameterGroupName"=>"default.mysql5.5"
-                                                            }
-                                      }
-                                 }
-            end
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @use_iam_profile = options[:use_iam_profile]
-          @region = options[:region] || 'us-east-1'
-
-          unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-central-1', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
-            raise ArgumentError, "Unknown region: #{@region.inspect}"
-          end
-        end
-
-        def data
-          self.class.data[@region][@aws_access_key_id]
-        end
-
-        def reset_data
-          self.class.data[@region].delete(@aws_access_key_id)
-        end
-
-        def setup_credentials(options)
-          @aws_access_key_id = options[:aws_access_key_id]
-        end
-      end
-
-      class Real
-        attr_reader :region
-
-        include Fog::AWS::CredentialFetcher::ConnectionMethods
-        # Initialize connection to ELB
-        #
-        # ==== Notes
-        # options parameter must include values for :aws_access_key_id and
-        # :aws_secret_access_key in order to create a connection
-        #
-        # ==== Examples
-        #   elb = ELB.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, 'eu-west-1', 'us-east-1' and etc.
-        #
-        # ==== Returns
-        # * ELB object with connection to AWS.
-        def initialize(options={})
-          @use_iam_profile = options[:use_iam_profile]
-          @instrumentor       = options[:instrumentor]
-          @instrumentor_name  = options[:instrumentor_name] || 'fog.aws.rds'
-          @connection_options     = options[:connection_options] || {}
-
-          @region     = options[:region]      || 'us-east-1'
-          @host       = options[:host]        || "rds.#{@region}.amazonaws.com"
-          @path       = options[:path]        || '/'
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 443
-          @scheme     = options[:scheme]      || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}#{@path}", @persistent, @connection_options)
-          @version    = options[:version] || '2013-05-15'
-
-          setup_credentials(options)
-        end
-
-        def owner_id
-          @owner_id ||= security_groups.get('default').owner_id
-        end
-
-        def reload
-          @connection.reset
-        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,'rds')
-        end
-
-        def request(params)
-          refresh_credentials_if_expired
-
-          idempotent  = params.delete(:idempotent)
-          parser      = params.delete(:parser)
-
-          body, headers = Fog::AWS.signed_params_v4(
-            params,
-            {'Content-Type' => 'application/x-www-form-urlencoded' },
-            {
-              :aws_session_token  => @aws_session_token,
-              :signer             => @signer,
-              :host               => @host,
-              :path               => @path,
-              :port               => @port,
-              :version            => @version,
-              :method             => 'POST'
-            }
-          )
-
-          if @instrumentor
-            @instrumentor.instrument("#{@instrumentor_name}.request", params) do
-              _request(body, headers, idempotent, parser)
-            end
-          else
-            _request(body, headers, idempotent, parser)
-          end
-        end
-
-        def _request(body, headers, idempotent, parser)
-          @connection.request({
-            :body       => body,
-            :expects    => 200,
-            :headers    => headers,
-            :idempotent => idempotent,
-            :method     => 'POST',
-            :parser     => parser
-          })
-        rescue Excon::Errors::HTTPStatusError => error
-          match = Fog::AWS::Errors.match_error(error)
-          if match.empty?
-            case error.message
-            when 'Not Found'
-              raise Fog::AWS::RDS::NotFound.slurp(error, 'RDS Instance not found')
-            else
-              raise
-            end
-          else
-            raise case match[:code]
-                  when 'DBInstanceNotFound', 'DBParameterGroupNotFound', 'DBSnapshotNotFound', 'DBSecurityGroupNotFound'
-                    Fog::AWS::RDS::NotFound.slurp(error, match[:message])
-                  when 'DBParameterGroupAlreadyExists'
-                    Fog::AWS::RDS::IdentifierTaken.slurp(error, match[:message])
-                  when 'AuthorizationAlreadyExists'
-                    Fog::AWS::RDS::AuthorizationAlreadyExists.slurp(error, match[:message])
-                  else
-                    Fog::AWS::RDS::Error.slurp(error, "#{match[:code]} => #{match[:message]}")
-                  end
-          end
-        end
-      end
-    end
-  end
-end