skylight 0.0.5 → 0.0.6

data/lib/skylight/vendor/excon/errors.rb

@@ -1,140 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      module Errors
-
-        class Error < StandardError; end
-        class StubNotFound < StandardError; end
-
-        class SocketError < Error
-          attr_reader :socket_error
-
-          def initialize(socket_error=nil)
-            if socket_error.message =~ /certificate verify failed/
-              super('Unable to verify certificate, please set `Excon.defaults[:ssl_ca_path] = path_to_certs`, `Excon.defaults[:ssl_ca_file] = path_to_file`, or `Excon.defaults[:ssl_verify_peer] = false` (less secure).')
-            else
-              super("#{socket_error.message} (#{socket_error.class})")
-            end
-            set_backtrace(socket_error.backtrace)
-            @socket_error = socket_error
-          end
-        end
-
-        class Timeout < Error; end
-
-        class ProxyParseError < Error; end
-
-        class ProxyConnectionError < Error; end
-
-        class HTTPStatusError < Error
-          attr_reader :request, :response
-
-          def initialize(msg, request = nil, response = nil)
-            super(msg)
-            @request = request
-            @response = response
-          end
-        end
-
-        class Continue < HTTPStatusError; end                     # 100
-        class SwitchingProtocols < HTTPStatusError; end           # 101
-        class OK < HTTPStatusError; end                           # 200
-        class Created < HTTPStatusError; end                      # 201
-        class Accepted < HTTPStatusError; end                     # 202
-        class NonAuthoritativeInformation < HTTPStatusError; end  # 203
-        class NoContent < HTTPStatusError; end                    # 204
-        class ResetContent < HTTPStatusError; end                 # 205
-        class PartialContent < HTTPStatusError; end               # 206
-        class MultipleChoices < HTTPStatusError; end              # 300
-        class MovedPermanently < HTTPStatusError; end             # 301
-        class Found < HTTPStatusError; end                        # 302
-        class SeeOther < HTTPStatusError; end                     # 303
-        class NotModified < HTTPStatusError; end                  # 304
-        class UseProxy < HTTPStatusError; end                     # 305
-        class TemporaryRedirect < HTTPStatusError; end            # 307
-        class BadRequest < HTTPStatusError; end                   # 400
-        class Unauthorized < HTTPStatusError; end                 # 401
-        class PaymentRequired < HTTPStatusError; end              # 402
-        class Forbidden < HTTPStatusError; end                    # 403
-        class NotFound < HTTPStatusError; end                     # 404
-        class MethodNotAllowed < HTTPStatusError; end             # 405
-        class NotAcceptable < HTTPStatusError; end                # 406
-        class ProxyAuthenticationRequired < HTTPStatusError; end  # 407
-        class RequestTimeout < HTTPStatusError; end               # 408
-        class Conflict < HTTPStatusError; end                     # 409
-        class Gone < HTTPStatusError; end                         # 410
-        class LengthRequired < HTTPStatusError; end               # 411
-        class PreconditionFailed < HTTPStatusError; end           # 412
-        class RequestEntityTooLarge < HTTPStatusError; end        # 413
-        class RequestURITooLong < HTTPStatusError; end            # 414
-        class UnsupportedMediaType < HTTPStatusError; end         # 415
-        class RequestedRangeNotSatisfiable < HTTPStatusError; end # 416
-        class ExpectationFailed < HTTPStatusError; end            # 417
-        class UnprocessableEntity < HTTPStatusError; end          # 422
-        class InternalServerError < HTTPStatusError; end          # 500
-        class NotImplemented < HTTPStatusError; end               # 501
-        class BadGateway < HTTPStatusError; end                   # 502
-        class ServiceUnavailable < HTTPStatusError; end           # 503
-        class GatewayTimeout < HTTPStatusError; end               # 504
-
-        # Messages for nicer exceptions, from rfc2616
-        def self.status_error(request, response)
-          @errors ||= {
-            100 => [Excon::Errors::Continue, 'Continue'],
-            101 => [Excon::Errors::SwitchingProtocols, 'Switching Protocols'],
-            200 => [Excon::Errors::OK, 'OK'],
-            201 => [Excon::Errors::Created, 'Created'],
-            202 => [Excon::Errors::Accepted, 'Accepted'],
-            203 => [Excon::Errors::NonAuthoritativeInformation, 'Non-Authoritative Information'],
-            204 => [Excon::Errors::NoContent, 'No Content'],
-            205 => [Excon::Errors::ResetContent, 'Reset Content'],
-            206 => [Excon::Errors::PartialContent, 'Partial Content'],
-            300 => [Excon::Errors::MultipleChoices, 'Multiple Choices'],
-            301 => [Excon::Errors::MovedPermanently, 'Moved Permanently'],
-            302 => [Excon::Errors::Found, 'Found'],
-            303 => [Excon::Errors::SeeOther, 'See Other'],
-            304 => [Excon::Errors::NotModified, 'Not Modified'],
-            305 => [Excon::Errors::UseProxy, 'Use Proxy'],
-            307 => [Excon::Errors::TemporaryRedirect, 'Temporary Redirect'],
-            400 => [Excon::Errors::BadRequest, 'Bad Request'],
-            401 => [Excon::Errors::Unauthorized, 'Unauthorized'],
-            402 => [Excon::Errors::PaymentRequired, 'Payment Required'],
-            403 => [Excon::Errors::Forbidden, 'Forbidden'],
-            404 => [Excon::Errors::NotFound, 'Not Found'],
-            405 => [Excon::Errors::MethodNotAllowed, 'Method Not Allowed'],
-            406 => [Excon::Errors::NotAcceptable, 'Not Acceptable'],
-            407 => [Excon::Errors::ProxyAuthenticationRequired, 'Proxy Authentication Required'],
-            408 => [Excon::Errors::RequestTimeout, 'Request Timeout'],
-            409 => [Excon::Errors::Conflict, 'Conflict'],
-            410 => [Excon::Errors::Gone, 'Gone'],
-            411 => [Excon::Errors::LengthRequired, 'Length Required'],
-            412 => [Excon::Errors::PreconditionFailed, 'Precondition Failed'],
-            413 => [Excon::Errors::RequestEntityTooLarge, 'Request Entity Too Large'],
-            414 => [Excon::Errors::RequestURITooLong, 'Request-URI Too Long'],
-            415 => [Excon::Errors::UnsupportedMediaType, 'Unsupported Media Type'],
-            416 => [Excon::Errors::RequestedRangeNotSatisfiable, 'Request Range Not Satisfiable'],
-            417 => [Excon::Errors::ExpectationFailed, 'Expectation Failed'],
-            422 => [Excon::Errors::UnprocessableEntity, 'Unprocessable Entity'],
-            500 => [Excon::Errors::InternalServerError, 'InternalServerError'],
-            501 => [Excon::Errors::NotImplemented, 'Not Implemented'],
-            502 => [Excon::Errors::BadGateway, 'Bad Gateway'],
-            503 => [Excon::Errors::ServiceUnavailable, 'Service Unavailable'],
-            504 => [Excon::Errors::GatewayTimeout, 'Gateway Timeout']
-          }
-
-          error, message = @errors[response[:status]] || [Excon::Errors::HTTPStatusError, 'Unknown']
-
-          # scrub authorization
-          request = request.dup
-          request.reject! {|key, value| [:connection, :stack].include?(key)}
-          if request.has_key?(:headers) && request[:headers].has_key?('Authorization')
-            request[:headers] = request[:headers].dup
-            request[:headers]['Authorization'] = REDACTED
-          end
-          error.new("Expected(#{request[:expects].inspect}) <=> Actual(#{response[:status]} #{message})\n  request => #{request.inspect}\n  response => #{response.inspect}", request, response)
-        end
-
-      end
-    end
-  end
-end

data/lib/skylight/vendor/excon/middlewares/base.rb

@@ -1,23 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      module Middleware
-        class Base
-          def initialize(stack)
-            @stack = stack
-          end
-
-          def request_call(datum)
-            # do stuff
-            @stack.request_call(datum)
-          end
-
-          def response_call(datum)
-            @stack.response_call(datum)
-            # do stuff
-          end
-        end
-      end
-    end
-  end
-end

data/lib/skylight/vendor/excon/middlewares/expects.rb

@@ -1,22 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      module Middleware
-        class Expects < Excon::Middleware::Base
-          def response_call(datum)
-            if datum.has_key?(:expects) && ![*datum[:expects]].include?(datum[:response][:status])
-              raise(
-                Excon::Errors.status_error(
-                  datum.reject {|key,value| key == :response},
-                  datum[:response]
-                )
-              )
-            else
-              @stack.response_call(datum)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/skylight/vendor/excon/middlewares/instrumentor.rb

@@ -1,31 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      module Middleware
-        class Instrumentor < Excon::Middleware::Base
-          def request_call(datum)
-            if datum.has_key?(:instrumentor)
-              if datum[:retries_remaining] < datum[:retry_limit]
-                event_name = "#{datum[:instrumentor_name]}.retry"
-              else
-                event_name = "#{datum[:instrumentor_name]}.request"
-              end
-              datum[:instrumentor].instrument(event_name, datum) do
-                @stack.request_call(datum)
-              end
-            else
-              @stack.request_call(datum)
-            end
-          end
-
-          def response_call(datum)
-            if datum.has_key?(:instrumentor)
-              datum[:instrumentor].instrument("#{datum[:instrumentor_name]}.response", datum[:response])
-            end
-            @stack.response_call(datum)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/skylight/vendor/excon/middlewares/mock.rb

@@ -1,88 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      module Middleware
-        class Mock < Excon::Middleware::Base
-          def request_call(datum)
-            if datum[:mock]
-              # convert File/Tempfile body to string before matching:
-              unless datum[:body].nil? || datum[:body].is_a?(String)
-               if datum[:body].respond_to?(:binmode)
-                 datum[:body].binmode
-               end
-               if datum[:body].respond_to?(:rewind)
-                 datum[:body].rewind
-               end
-               datum[:body] = datum[:body].read
-              end
-
-              datum[:captures] = {:headers => {}} # setup data to hold captures
-              Excon.stubs.each do |stub, response|
-                headers_match = !stub.has_key?(:headers) || stub[:headers].keys.all? do |key|
-                  case value = stub[:headers][key]
-                  when Regexp
-                    if match = value.match(datum[:headers][key])
-                      datum[:captures][:headers][key] = match.captures
-                    end
-                    match
-                  else
-                    value == datum[:headers][key]
-                  end
-                end
-                non_headers_match = (stub.keys - [:headers]).all? do |key|
-                  case value = stub[key]
-                  when Regexp
-                    if match = value.match(datum[key])
-                      datum[:captures][key] = match.captures
-                    end
-                    match
-                  else
-                    value == datum[key]
-                  end
-                end
-                if headers_match && non_headers_match
-                  datum[:response] = {
-                    :body       => '',
-                    :headers    => {},
-                    :status     => 200,
-                    :remote_ip  => '127.0.0.1'
-                  }
-
-                  stub_datum = case response
-                  when Proc
-                    response.call(datum)
-                  else
-                    response
-                  end
-
-                  datum[:response].merge!(stub_datum.reject {|key,value| key == :headers})
-                  if stub_datum.has_key?(:headers)
-                    datum[:response][:headers].merge!(stub_datum[:headers])
-                  end
-
-                  if datum[:expects] && ![*datum[:expects]].include?(datum[:response][:status])
-                    # don't pass stuff into a block if there was an error
-                  elsif datum.has_key?(:response_block) && datum[:response].has_key?(:body)
-                    body = datum[:response].delete(:body)
-                    content_length = remaining = body.bytesize
-                    i = 0
-                    while i < body.length
-                      datum[:response_block].call(body[i, datum[:chunk_size]], [remaining - datum[:chunk_size], 0].max, content_length)
-                      remaining -= datum[:chunk_size]
-                      i += datum[:chunk_size]
-                    end
-                  end
-                  return @stack.request_call(datum)
-                end
-              end
-              # if we reach here no stubs matched
-              raise(Excon::Errors::StubNotFound.new('no stubs matched ' << datum.inspect))
-            else
-              @stack.request_call(datum)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/skylight/vendor/excon/response.rb

@@ -1,68 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      class Response
-
-        attr_accessor :data
-
-        # backwards compatability reader/writers
-        def body=(new_body)
-          @data[:body] = new_body
-        end
-        def body
-          @data[:body]
-        end
-        def headers=(new_headers)
-          @data[:headers] = new_headers
-        end
-        def headers
-          @data[:headers]
-        end
-        def status=(new_status)
-          @data[:status] = new_status
-        end
-        def status
-          @data[:status]
-        end
-        def remote_ip=(new_remote_ip)
-          @data[:remote_ip] = new_remote_ip
-        end
-        def remote_ip
-          @data[:remote_ip]
-        end
-
-        def initialize(params={})
-          @data = {
-            :body     => '',
-            :headers  => {}
-          }.merge(params)
-          @body      = @data[:body]
-          @headers   = @data[:headers]
-          @status    = @data[:status]
-          @remote_ip = @data[:remote_ip]
-        end
-
-        def [](key)
-          @data[key]
-        end
-
-        def params
-          $stderr.puts("Excon::Response#params is deprecated use Excon::Response#data instead (#{caller.first})")
-          data
-        end
-
-        # Retrieve a specific header value. Header names are treated case-insensitively.
-        #   @param [String] name Header name
-        def get_header(name)
-          headers.each do |key,value|
-            if key.casecmp(name) == 0
-              return value
-            end
-          end
-          nil
-        end
-
-      end # class Response
-    end # module Excon
-  end
-end

data/lib/skylight/vendor/excon/socket.rb

@@ -1,206 +0,0 @@
-module Skylight
-  module Vendor
-    module Excon
-      class Socket
-
-        extend Forwardable
-
-        attr_accessor :data
-
-        def params
-          $stderr.puts("Excon::Socket#params is deprecated use Excon::Socket#data instead (#{caller.first})")
-          @data
-        end
-        def params=(new_params)
-          $stderr.puts("Excon::Socket#params= is deprecated use Excon::Socket#data= instead (#{caller.first})")
-          @data = new_params
-        end
-
-        attr_reader :remote_ip
-
-        def_delegators(:@socket, :close,    :close)
-        def_delegators(:@socket, :readline, :readline)
-
-        def initialize(data = {})
-          @data = data
-          @read_buffer = ''
-          @eof = false
-
-          @data[:family] ||= ::Socket::Constants::AF_UNSPEC
-          if @data[:proxy]
-            @data[:proxy][:family]  ||= ::Socket::Constants::AF_UNSPEC
-          end
-
-          connect
-        end
-
-        def connect
-          @socket = nil
-          exception = nil
-
-          addrinfo = if @data[:proxy]
-            ::Socket.getaddrinfo(@data[:proxy][:host], @data[:proxy][:port], @data[:proxy][:family], ::Socket::Constants::SOCK_STREAM)
-          else
-            ::Socket.getaddrinfo(@data[:host], @data[:port], @data[:family], ::Socket::Constants::SOCK_STREAM)
-          end
-
-          addrinfo.each do |_, port, _, ip, a_family, s_type|
-            @remote_ip = ip
-
-            # nonblocking connect
-            begin
-              sockaddr = ::Socket.sockaddr_in(port, ip)
-
-              socket = ::Socket.new(a_family, s_type, 0)
-
-              if @data[:nonblock]
-                socket.connect_nonblock(sockaddr)
-              else
-                begin
-                  Timeout.timeout(@data[:connect_timeout]) do
-                    socket.connect(sockaddr)
-                  end
-                rescue Timeout::Error
-                  raise Excon::Errors::Timeout.new('connect timeout reached')
-                end
-              end
-
-              @socket = socket
-              break
-            rescue Errno::EINPROGRESS
-              unless IO.select(nil, [socket], nil, @data[:connect_timeout])
-                raise(Excon::Errors::Timeout.new("connect timeout reached"))
-              end
-              begin
-                socket.connect_nonblock(sockaddr)
-
-                @socket = socket
-                break
-              rescue Errno::EISCONN
-                @socket = socket
-                break
-              rescue SystemCallError => exception
-                socket.close
-                next
-              end
-            rescue SystemCallError => exception
-              socket.close
-              next
-            end
-          end
-
-          unless @socket
-            # this will be our last encountered exception
-            raise exception
-          end
-        end
-
-        def read(max_length=nil)
-          if @eof
-            return nil
-          elsif @data[:nonblock]
-            begin
-              if max_length
-                until @read_buffer.length >= max_length
-                  @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
-                end
-              else
-                while true
-                  @read_buffer << @socket.read_nonblock(@data[:chunk_size])
-                end
-              end
-            rescue OpenSSL::SSL::SSLError => error
-              if error.message == 'read would block'
-                if IO.select([@socket], nil, nil, @data[:read_timeout])
-                  retry
-                else
-                  raise(Excon::Errors::Timeout.new("read timeout reached"))
-                end
-              else
-                raise(error)
-              end
-            rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
-              if IO.select([@socket], nil, nil, @data[:read_timeout])
-                retry
-              else
-                raise(Excon::Errors::Timeout.new("read timeout reached"))
-              end
-            rescue EOFError
-              @eof = true
-            end
-            if max_length
-              @read_buffer.slice!(0, max_length)
-            else
-              # read until EOFError, so return everything
-              @read_buffer.slice!(0, @read_buffer.length)
-            end
-          else
-            begin
-              Timeout.timeout(@data[:read_timeout]) do
-                @socket.read(max_length)
-              end
-            rescue Timeout::Error
-              raise Excon::Errors::Timeout.new('read timeout reached')
-            end
-          end
-        end
-
-        def write(data)
-          if @data[:nonblock]
-            # We normally return from the return in the else block below, but
-            # we guard that data is still something in case we get weird
-            # values and String#[] returns nil. (This behavior has been observed
-            # in the wild, so this is a simple defensive mechanism)
-            while data
-              begin
-                # I wish that this API accepted a start position, then we wouldn't
-                # have to slice data when there is a short write.
-                written = @socket.write_nonblock(data)
-              rescue OpenSSL::SSL::SSLError => error
-                if error.message == 'write would block'
-                  if IO.select(nil, [@socket], nil, @data[:write_timeout])
-                    retry
-                  else
-                    raise(Excon::Errors::Timeout.new("write timeout reached"))
-                  end
-                else
-                  raise(error)
-                end
-              rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable
-                if IO.select(nil, [@socket], nil, @data[:write_timeout])
-                  retry
-                else
-                  raise(Excon::Errors::Timeout.new("write timeout reached"))
-                end
-              else
-                # Fast, common case.
-                # The >= seems weird, why would it have written MORE than we
-                # requested. But we're getting some weird behavior when @socket
-                # is an OpenSSL socket, where it seems like it's saying it wrote
-                # more (perhaps due to SSL packet overhead?).
-                #
-                # Pretty weird, but this is a simple defensive mechanism.
-                return if written >= data.size
-
-                # This takes advantage of the fact that most ruby implementations
-                # have Copy-On-Write strings. Thusly why requesting a subrange
-                # of data, we actually don't copy data because the new string
-                # simply references a subrange of the original.
-                data = data[written, data.size]
-              end
-            end
-          else
-            begin
-              Timeout.timeout(@data[:write_timeout]) do
-                @socket.write(data)
-              end
-            rescue Timeout::Error
-              Excon::Errors::Timeout.new('write timeout reached')
-            end
-          end
-        end
-
-      end
-    end
-  end
-end