framed_rails 0.1.0

data/vendor/gems/excon-0.45.3/lib/excon/response.rb

@@ -0,0 +1,212 @@
+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 status_line
+      @data[:status_line]
+    end
+    def status_line=(new_status_line)
+      @data[:status_line] = new_status_line
+    end
+    def reason_phrase=(new_reason_phrase)
+      @data[:reason_phrase] = new_reason_phrase
+    end
+    def reason_phrase
+      @data[:reason_phrase]
+    end
+    def remote_ip=(new_remote_ip)
+      @data[:remote_ip] = new_remote_ip
+    end
+    def remote_ip
+      @data[:remote_ip]
+    end
+    def local_port
+      @data[:local_port]
+    end
+    def local_address
+      @data[:local_address]
+    end
+
+    def self.parse(socket, datum)
+      # this will discard any trailing lines from the previous response if any.
+      begin
+        line = socket.readline
+      end until status = line[9, 3].to_i
+
+      reason_phrase = line[13..-3] # -3 strips the trailing "\r\n"
+
+      datum[:response] = {
+        :body          => '',
+        :headers       => Excon::Headers.new,
+        :status        => status,
+        :status_line   => line,
+        :reason_phrase => reason_phrase
+      }
+
+      unix_proxy = datum[:proxy] ? datum[:proxy][:scheme] == UNIX : false
+      unless datum[:scheme] == UNIX || unix_proxy
+        datum[:response].merge!(
+          :remote_ip     => socket.remote_ip,
+          :local_port    => socket.local_port,
+          :local_address => socket.local_address
+        )
+      end
+
+      parse_headers(socket, datum)
+
+      unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
+
+        if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Transfer-Encoding') == 0 }
+          encodings = Utils.split_header_value(datum[:response][:headers][key])
+          if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
+            transfer_encoding_chunked = true
+            if encodings.length == 1
+              datum[:response][:headers].delete(key)
+            else
+              datum[:response][:headers][key] = encodings[0...-1].join(', ')
+            end
+          end
+        end
+
+        # use :response_block unless :expects would fail
+        if response_block = datum[:response_block]
+          if datum[:middlewares].include?(Excon::Middleware::Expects) && datum[:expects] &&
+                                !Array(datum[:expects]).include?(datum[:response][:status])
+            response_block = nil
+          end
+        end
+
+        if transfer_encoding_chunked
+          if response_block
+            while (chunk_size = socket.readline.chomp!.to_i(16)) > 0
+              while chunk_size > 0
+                chunk = socket.read(chunk_size)
+                chunk_size -= chunk.bytesize
+                response_block.call(chunk, nil, nil)
+              end
+              new_line_size = 2 # 2 == "\r\n".length
+              while new_line_size > 0
+                new_line_size -= socket.read(new_line_size).length
+              end
+            end
+          else
+            while (chunk_size = socket.readline.chomp!.to_i(16)) > 0
+              while chunk_size > 0
+                chunk = socket.read(chunk_size)
+                chunk_size -= chunk.bytesize
+                datum[:response][:body] << chunk
+              end
+              new_line_size = 2 # 2 == "\r\n".length
+              while new_line_size > 0
+                new_line_size -= socket.read(new_line_size).length
+              end
+            end
+          end
+          parse_headers(socket, datum) # merge trailers into headers
+        else
+          if key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 }
+            content_length = datum[:response][:headers][key].to_i
+          end
+
+          if remaining = content_length
+            if response_block
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min)
+                response_block.call(chunk, [remaining - chunk.bytesize, 0].max, content_length)
+                remaining -= chunk.bytesize
+              end
+            else
+              while remaining > 0
+                chunk = socket.read([datum[:chunk_size], remaining].min)
+                datum[:response][:body] << chunk
+                remaining -= chunk.bytesize
+              end
+            end
+          else
+            if response_block
+              while chunk = socket.read(datum[:chunk_size])
+                response_block.call(chunk, nil, nil)
+              end
+            else
+              while chunk = socket.read(datum[:chunk_size])
+                datum[:response][:body] << chunk
+              end
+            end
+          end
+        end
+      end
+      datum
+    end
+
+    def self.parse_headers(socket, datum)
+      last_key = nil
+      until (data = socket.readline.chomp!).empty?
+        if !data.lstrip!.nil?
+          raise Excon::Errors::ResponseParseError, 'malformed header' unless last_key
+          # append to last_key's last value
+          datum[:response][:headers][last_key] << ' ' << data.rstrip
+        else
+          key, value = data.split(':', 2)
+          raise Excon::Errors::ResponseParseError, 'malformed header' unless value
+          # add key/value or append value to existing values
+          datum[:response][:headers][key] = ([datum[:response][:headers][key]] << value.strip).compact.join(', ')
+          last_key = key
+        end
+      end
+    end
+
+    def initialize(params={})
+      @data = {
+        :body     => ''
+      }.merge(params)
+      @data[:headers] = Excon::Headers.new.merge!(params[:headers] || {})
+
+      @body          = @data[:body]
+      @headers       = @data[:headers]
+      @status        = @data[:status]
+      @remote_ip     = @data[:remote_ip]
+      @local_port    = @data[:local_port]
+      @local_address = @data[:local_address]
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def params
+      Excon.display_warning('Excon::Response#params is deprecated use Excon::Response#data instead.')
+      data
+    end
+
+    def pp
+      Excon::PrettyPrinter.pp($stdout, @data)
+    end
+
+    # Retrieve a specific header value. Header names are treated case-insensitively.
+    #   @param [String] name Header name
+    def get_header(name)
+      headers[name]
+    end
+
+  end # class Response
+end # module Excon

data/vendor/gems/excon-0.45.3/lib/excon/socket.rb

@@ -0,0 +1,310 @@
+module Excon
+  class Socket
+    include Utils
+
+    extend Forwardable
+
+    attr_accessor :data
+
+    def params
+      Excon.display_warning('Excon::Socket#params is deprecated use Excon::Socket#data instead.')
+      @data
+    end
+
+    def params=(new_params)
+      Excon.display_warning('Excon::Socket#params= is deprecated use Excon::Socket#data= instead.')
+      @data = new_params
+    end
+
+    attr_reader :remote_ip
+
+    def_delegators(:@socket, :close)
+
+    def initialize(data = {})
+      @data = data
+      @nonblock = data[:nonblock]
+      @read_buffer = ''
+      @eof = false
+      connect
+    end
+
+    def read(max_length = nil)
+      if @eof
+        return max_length ? nil : ''
+      elsif @nonblock
+        read_nonblock(max_length)
+      else
+        read_block(max_length)
+      end
+    end
+
+    def readline
+      return legacy_readline if RUBY_VERSION.to_f <= 1.8_7
+      buffer = ''
+      begin
+        buffer << @socket.read_nonblock(1) while buffer[-1] != "\n"
+        buffer
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable 
+        if timeout_reached('read')
+          raise_timeout_error('read')
+        else
+          retry
+        end
+      rescue OpenSSL::SSL::SSLError => e
+        if e.message == 'read would block'
+          if timeout_reached('read')
+            raise_timeout_error('read')
+          else
+            retry
+          end
+        else
+          raise(error)
+        end
+      end
+    end
+
+    def legacy_readline
+      begin
+        Timeout.timeout(@data[:read_timeout]) do
+          @socket.readline
+        end
+      rescue Timeout::Error
+        raise Excon::Errors::Timeout.new('read timeout reached')
+      end
+    end
+
+    def write(data)
+      if @nonblock
+        write_nonblock(data)
+      else
+        write_block(data)
+      end
+    end
+
+    def local_address
+      unpacked_sockaddr[1]
+    end
+
+    def local_port
+      unpacked_sockaddr[0]
+    end
+
+    private
+
+    def connect
+      @socket = nil
+      exception = nil
+
+      if @data[:proxy]
+        family = @data[:proxy][:family] || ::Socket::Constants::AF_UNSPEC
+        args = [@data[:proxy][:hostname], @data[:proxy][:port], family, ::Socket::Constants::SOCK_STREAM]
+      else
+        family = @data[:family] || ::Socket::Constants::AF_UNSPEC
+        args = [@data[:hostname], @data[:port], family, ::Socket::Constants::SOCK_STREAM]
+      end
+      if RUBY_VERSION >= '1.9.2' && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+        args << nil << nil << false # no reverse lookup
+      end
+      addrinfo = ::Socket.getaddrinfo(*args)
+
+      addrinfo.each do |_, port, _, ip, a_family, s_type|
+        @remote_ip = ip
+
+        # already succeeded on previous addrinfo
+        if @socket
+          break
+        end
+
+        # nonblocking connect
+        begin
+          sockaddr = ::Socket.sockaddr_in(port, ip)
+
+          socket = ::Socket.new(a_family, s_type, 0)
+
+          if @data[:reuseaddr]
+            socket.setsockopt(::Socket::Constants::SOL_SOCKET, ::Socket::Constants::SO_REUSEADDR, true)
+            if defined?(::Socket::Constants::SO_REUSEPORT)
+              socket.setsockopt(::Socket::Constants::SOL_SOCKET, ::Socket::Constants::SO_REUSEPORT, true)
+            end
+          end
+
+          if @nonblock
+            socket.connect_nonblock(sockaddr)
+          else
+            socket.connect(sockaddr)
+          end
+          @socket = socket
+        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
+          rescue Errno::EISCONN
+            @socket = socket
+          rescue SystemCallError => exception
+            socket.close rescue nil
+          end
+        rescue SystemCallError => exception
+          socket.close rescue nil if socket
+        end
+      end
+
+      # this will be our last encountered exception
+      fail exception unless @socket
+
+      if @data[:tcp_nodelay]
+        @socket.setsockopt(::Socket::IPPROTO_TCP,
+                           ::Socket::TCP_NODELAY,
+                           true)
+      end
+    end
+
+    def read_nonblock(max_length)
+      begin
+        if max_length
+          until @read_buffer.length >= max_length
+            @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+          end
+        else
+          loop do
+            @read_buffer << @socket.read_nonblock(@data[:chunk_size])
+          end
+        end
+      rescue OpenSSL::SSL::SSLError => error
+        if error.message == 'read would block'
+          if timeout_reached('read')  
+            raise_timeout_error('read') 
+          else 
+            retry
+          end
+        else
+          raise(error)
+        end
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+        if @read_buffer.empty?
+          # if we didn't read anything, try again...
+          if timeout_reached('read') 
+            raise_timeout_error('read') 
+          else
+            retry
+          end
+        end
+      rescue EOFError
+        @eof = true
+      end
+
+      if max_length
+        if @read_buffer.empty?
+          nil # EOF met at beginning
+        else
+          @read_buffer.slice!(0, max_length)
+        end
+      else
+        # read until EOFError, so return everything
+        @read_buffer.slice!(0, @read_buffer.length)
+      end
+    end
+
+    def read_block(max_length)
+      @socket.read(max_length)
+    rescue OpenSSL::SSL::SSLError => error
+      if error.message == 'read would block'
+        if timeout_reached('read') 
+          raise_timeout_error('read') 
+        else
+          retry
+        end
+      else
+        raise(error)
+      end
+    rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+      if @read_buffer.empty?
+        if timeout_reached('read') 
+          raise_timeout_error('read') 
+        else
+          retry
+        end
+      end
+    rescue EOFError
+      @eof = true
+    end
+
+    def write_nonblock(data)
+      if FORCE_ENC
+        data.force_encoding('BINARY')
+      end
+      loop do
+        written = nil
+        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 Errno::EFAULT
+          if OpenSSL.const_defined?(:OPENSSL_LIBRARY_VERSION) && OpenSSL::OPENSSL_LIBRARY_VERSION.split(' ')[1] == '1.0.2'
+            msg = "The version of OpenSSL this ruby is built against (1.0.2) has a vulnerability
+                   which causes a fault. For more, see https://github.com/excon/excon/issues/467"
+            raise SecurityError.new(msg)
+          else
+            raise error
+          end
+        rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+          if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
+            raise error
+          else
+            if timeout_reached('write') 
+              raise_timeout_error('write') 
+            else 
+              retry
+            end
+          end
+        end
+
+        # Fast, common case.
+        break 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
+
+    def write_block(data)
+      @socket.write(data)
+    rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
+      if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
+        raise error
+      else
+        if timeout_reached('write') 
+          raise_timeout_error('write') 
+        else
+          retry
+        end
+      end
+    end
+
+    def timeout_reached(type)
+      if type == 'read'
+        args = [[@socket], nil, nil, @data[:read_timeout]]
+      else
+        args = [nil, [@socket], nil, @data[:write_timeout]]
+      end
+      IO.select(*args) ? nil : true
+    end
+
+    def raise_timeout_error(type)
+      fail Excon::Errors::Timeout.new("#{type} timeout reached")
+    end
+
+    def unpacked_sockaddr
+      @unpacked_sockaddr ||= ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)
+    rescue ArgumentError => e
+      unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
+        raise
+      end
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/ssl_socket.rb

@@ -0,0 +1,151 @@
+module Excon
+  class SSLSocket < Socket
+    HAVE_NONBLOCK = [:connect_nonblock, :read_nonblock, :write_nonblock].all? do |m|
+      OpenSSL::SSL::SSLSocket.public_method_defined?(m)
+    end
+
+    def initialize(data = {})
+      super
+
+      # create ssl context
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      # disable less secure options, when supported
+      ssl_context_options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
+      if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
+        ssl_context_options &= ~OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
+      end
+
+      if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
+        ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
+      end
+      ssl_context.options = ssl_context_options
+
+      ssl_context.ciphers = @data[:ciphers]
+      if @data[:ssl_version]
+        ssl_context.ssl_version = @data[:ssl_version]
+      end
+
+      if @data[:ssl_verify_peer]
+        # turn verification on
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        if ca_file = @data[:ssl_ca_file] || ENV['SSL_CERT_FILE']
+          ssl_context.ca_file = ca_file
+        end
+        if ca_path = @data[:ssl_ca_path] || ENV['SSL_CERT_DIR']
+          ssl_context.ca_path = ca_path
+        end
+        if cert_store = @data[:ssl_cert_store]
+          ssl_context.cert_store = cert_store
+        end
+
+        # no defaults, fallback to bundled
+        unless ca_file || ca_path || cert_store
+          ssl_context.cert_store = OpenSSL::X509::Store.new
+          ssl_context.cert_store.set_default_paths
+
+          # workaround issue #257 (JRUBY-6970)
+          ca_file = DEFAULT_CA_FILE
+          ca_file.gsub!(/^jar:/, '') if ca_file =~ /^jar:file:\//
+
+          begin
+            ssl_context.cert_store.add_file(ca_file)
+          rescue
+            Excon.display_warning("Excon unable to add file to cert store, ignoring: #{ca_file}\n[#{$!.class}] #{$!.message}")
+          end
+        end
+
+        if verify_callback = @data[:ssl_verify_callback]
+          ssl_context.verify_callback = verify_callback
+        end
+      else
+        # turn verification off
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      # maintain existing API
+      certificate_path = @data[:client_cert] || @data[:certificate_path]
+      private_key_path = @data[:client_key] || @data[:private_key_path]
+      private_key_pass = @data[:client_key_pass] || @data[:private_key_pass]
+
+      if certificate_path && private_key_path
+        ssl_context.cert = OpenSSL::X509::Certificate.new(File.read(certificate_path))
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(File.read(private_key_path), private_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(File.read(private_key_path), private_key_pass)
+        end
+      elsif @data.key?(:certificate) && @data.key?(:private_key)
+        ssl_context.cert = OpenSSL::X509::Certificate.new(@data[:certificate])
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(@data[:private_key], private_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(@data[:private_key], private_key_pass)
+        end
+      end
+
+      if @data[:proxy]
+        request = 'CONNECT ' << @data[:host] << port_string(@data.merge(:omit_default_port => false)) << Excon::HTTP_1_1
+        request << 'Host: ' << @data[:host] << port_string(@data) << Excon::CR_NL
+
+        if @data[:proxy][:password] || @data[:proxy][:user]
+          auth = ['' << @data[:proxy][:user].to_s << ':' << @data[:proxy][:password].to_s].pack('m').delete(Excon::CR_NL)
+          request << 'Proxy-Authorization: Basic ' << auth << Excon::CR_NL
+        end
+
+        request << 'Proxy-Connection: Keep-Alive' << Excon::CR_NL
+
+        request << Excon::CR_NL
+
+        # write out the proxy setup request
+        @socket.write(request)
+
+        # eat the proxy's connection response
+        Excon::Response.parse(self,  :expects => 200, :method => 'CONNECT')
+      end
+
+      # convert Socket to OpenSSL::SSL::SSLSocket
+      @socket = OpenSSL::SSL::SSLSocket.new(@socket, ssl_context)
+      @socket.sync_close = true
+
+      # Server Name Indication (SNI) RFC 3546
+      if @socket.respond_to?(:hostname=)
+        @socket.hostname = @data[:host]
+      end
+
+      begin
+        if @nonblock
+          begin
+            @socket.connect_nonblock
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            IO.select([@socket])
+            retry
+          rescue IO::WaitWritable
+            IO.select(nil, [@socket])
+            retry
+          end
+        else
+          @socket.connect
+        end
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        raise Excon::Errors::Timeout.new('connect timeout reached')
+      end
+
+      # verify connection
+      if @data[:ssl_verify_peer]
+        @socket.post_connection_check(@data[:ssl_verify_peer_host] || @data[:host])
+      end
+
+      @socket
+    end
+
+    private
+
+    def connect
+      # backwards compatability for things lacking nonblock
+      @nonblock = HAVE_NONBLOCK && @nonblock
+      super
+    end
+  end
+end

data/vendor/gems/excon-0.45.3/lib/excon/standard_instrumentor.rb

@@ -0,0 +1,27 @@
+module Excon
+  class StandardInstrumentor
+    def self.instrument(name, params = {}, &block)
+      params = params.dup
+
+      # reduce duplication/noise of output
+      params.delete(:connection)
+      params.delete(:stack)
+
+      if params.has_key?(:headers) && params[:headers].has_key?('Authorization')
+        params[:headers] = params[:headers].dup
+        params[:headers]['Authorization'] = REDACTED
+      end
+
+      if params.has_key?(:password)
+        params[:password] = REDACTED
+      end
+
+      $stderr.puts(name)
+      Excon::PrettyPrinter.pp($stderr, params)
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end