skylight 0.0.2 → 0.0.5

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

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

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

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

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

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

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

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