z-http-request 0.1.0

data/lib/z-http/http_connection.rb

@@ -0,0 +1,214 @@
+module ZMachine
+
+  module HTTPMethods
+    def get      options = {}, &blk;  setup_request(:get,     options, &blk); end
+    def head     options = {}, &blk;  setup_request(:head,    options, &blk); end
+    def delete   options = {}, &blk;  setup_request(:delete,  options, &blk); end
+    def put      options = {}, &blk;  setup_request(:put,     options, &blk); end
+    def post     options = {}, &blk;  setup_request(:post,    options, &blk); end
+    def patch    options = {}, &blk;  setup_request(:patch,   options, &blk); end
+    def options  options = {}, &blk;  setup_request(:options, options, &blk); end
+  end
+
+  class HttpStubConnection < Connection
+    include Deferrable
+    attr_reader :parent
+
+    def parent=(p)
+      @parent = p
+      @parent.conn = self
+    end
+
+    def receive_data(data)
+      @parent.receive_data data
+    end
+
+    def connection_completed
+      @parent.connection_completed
+    end
+
+    def unbind(reason=nil)
+      @parent.unbind(reason)
+    end
+  end
+
+  class HttpConnection
+    include HTTPMethods
+
+    attr_reader :deferred
+    attr_accessor :error, :connopts, :uri, :conn
+
+    def initialize
+      @deferred = true
+      @middleware = []
+    end
+
+    def conn=(c)
+      @conn = c
+      @deferred = false
+    end
+
+    def activate_connection(client)
+      begin
+        ZMachine.connect(@connopts.host, @connopts.port, HttpStubConnection) do |conn|
+          post_init
+
+          @deferred = false
+          @conn = conn
+
+          conn.parent = self
+          conn.pending_connect_timeout = @connopts.connect_timeout
+          conn.comm_inactivity_timeout = @connopts.inactivity_timeout
+        end
+
+        finalize_request(client)
+      rescue ZMachine::ConnectionError => e
+        #
+        # Currently, this can only fire on initial connection setup
+        # since #connect is a synchronous method. Hence, rescue the exception,
+        # and return a failed deferred which fail any client request at next
+        # tick.  We fail at next tick to keep a consistent API when the newly
+        # created HttpClient is failed. This approach has the advantage to
+        # remove a state check of @deferred_status after creating a new
+        # HttpRequest. The drawback is that users may setup a callback which we
+        # know won't be used.
+        #
+        # Once there is async-DNS, then we'll iterate over the outstanding
+        # client requests and fail them in order.
+        #
+        # Net outcome: failed connection will invoke the same ConnectionError
+        # message on the connection deferred, and on the client deferred.
+        #
+        ZMachine.next_tick{client.close(e.message)}
+      end
+    end
+
+    def setup_request(method, options = {}, c = nil)
+      c ||= HttpClient.new(self, HttpClientOptions.new(@uri, options, method))
+      @deferred ? activate_connection(c) : finalize_request(c)
+      c
+    end
+
+    def finalize_request(c)
+      @conn.callback { c.connection_completed }
+
+      middleware.each do |m|
+        c.callback(&m.method(:response)) if m.respond_to?(:response)
+      end
+
+      @clients.push c
+    end
+
+    def middleware
+      [HttpRequest.middleware, @middleware].flatten
+    end
+
+    def post_init
+      @clients = []
+      @pending = []
+
+      @p = Http::Parser.new
+      @p.header_value_type = :mixed
+      @p.on_headers_complete = proc do |h|
+        client.parse_response_header(h, @p.http_version, @p.status_code)
+        :reset if client.req.no_body?
+      end
+
+      @p.on_body = proc do |b|
+        client.on_body_data(b)
+      end
+
+      @p.on_message_complete = proc do
+        if !client.continue?
+          c = @clients.shift
+          c.state = :finished
+          c.on_request_complete
+        end
+      end
+    end
+
+    def use(klass, *args, &block)
+      @middleware << klass.new(*args, &block)
+    end
+
+    def peer
+      Socket.unpack_sockaddr_in(@peer)[1] rescue nil
+    end
+
+    def receive_data(data)
+      begin
+        @p << data
+      rescue HTTP::Parser::Error => e
+        c = @clients.shift
+        c.nil? ? unbind(e.message) : c.on_error(e.message)
+      end
+    end
+
+    def connection_completed
+      @peer = @conn.get_peername
+
+      if @connopts.socks_proxy?
+        raise NotImplementedError
+      elsif @connopts.connect_proxy?
+        raise NotImplementedError
+      else
+        start
+      end
+    end
+
+    def start
+      @conn.start_tls(@connopts.tls) if client && client.req.ssl?
+      @conn.succeed
+    end
+
+    def redirect(client)
+      @pending.push client
+    end
+
+    def unbind(reason = nil)
+      #reason ||= Errno::ETIMEDOUT if @conn.channel.timedout?
+      @clients.map { |c| c.unbind(reason) }
+
+      if r = @pending.shift
+        @clients.push r
+
+        r.reset!
+        @p.reset!
+
+        begin
+          @conn.set_deferred_status :unknown
+
+          if @connopts.proxy
+            @conn.reconnect(@connopts.host, @connopts.port)
+          else
+            @conn.reconnect(r.req.host, r.req.port)
+          end
+
+          @conn.pending_connect_timeout = @connopts.connect_timeout
+          @conn.comm_inactivity_timeout = @connopts.inactivity_timeout
+          @conn.callback { r.connection_completed }
+        rescue ZMachine::ConnectionError => e
+          @clients.pop.close(e.message)
+        end
+      else
+        @deferred = true
+        @conn.close_connection
+      end
+    end
+    alias :close :unbind
+
+    def send_data(data)
+      @conn.send_data data
+    end
+
+    def stream_file_data(filename, args = {})
+      @conn.stream_file_data filename, args
+    end
+
+    private
+
+      def client
+        @clients.first
+      end
+  end
+end

data/lib/z-http/http_connection_options.rb

@@ -0,0 +1,44 @@
+class HttpConnectionOptions
+  attr_reader :host, :port, :tls, :proxy, :bind, :bind_port
+  attr_reader :connect_timeout, :inactivity_timeout
+
+  def initialize(uri, options)
+    @connect_timeout     = options[:connect_timeout] || 5        # default connection setup timeout
+    @inactivity_timeout  = options[:inactivity_timeout] ||= 10   # default connection inactivity (post-setup) timeout
+
+    @tls   = options[:tls] || options[:ssl] || {}
+    @proxy = options[:proxy]
+
+    if bind = options[:bind]
+      @bind = bind[:host] || '0.0.0.0'
+
+      # ZMachine will open a UNIX socket if bind :port
+      # is explicitly set to nil
+      @bind_port = bind[:port]
+    end
+
+    uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
+    @https = uri.scheme == "https"
+    uri.port ||= (@https ? 443 : 80)
+
+    if proxy = options[:proxy]
+      @host = proxy[:host]
+      @port = proxy[:port]
+    else
+      @host = uri.host
+      @port = uri.port
+    end
+  end
+
+  def http_proxy?
+    @proxy && (@proxy[:type] == :http || @proxy[:type].nil?) && !@https
+  end
+
+  def connect_proxy?
+    @proxy && (@proxy[:type] == :http || @proxy[:type].nil?) && @https
+  end
+
+  def socks_proxy?
+    @proxy && (@proxy[:type] == :socks5)
+  end
+end

data/lib/z-http/http_encoding.rb

@@ -0,0 +1,142 @@
+module ZMachine
+  module HttpEncoding
+    HTTP_REQUEST_HEADER="%s %s HTTP/1.1\r\n"
+    FIELD_ENCODING = "%s: %s\r\n"
+
+    def escape(s)
+      if defined?(EscapeUtils)
+        EscapeUtils.escape_url(s.to_s)
+      else
+        s.to_s.gsub(/([^a-zA-Z0-9_.-]+)/) {
+          '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+        }
+      end
+    end
+
+    def unescape(s)
+      if defined?(EscapeUtils)
+        EscapeUtils.unescape_url(s.to_s)
+      else
+        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/) {
+          [$1.delete('%')].pack('H*')
+        }
+      end
+    end
+
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+
+    # Map all header keys to a downcased string version
+    def munge_header_keys(head)
+      head.inject({}) { |h, (k, v)| h[k.to_s.downcase] = v; h }
+    end
+
+    def encode_host
+      if @req.uri.port == 80 || @req.uri.port == 443
+        return @req.uri.host
+      else
+        @req.uri.host + ":#{@req.uri.port}"
+      end
+    end
+
+    def encode_request(method, uri, query, proxy)
+      query = encode_query(uri, query)
+
+      # Non CONNECT proxies require that you provide the full request
+      # uri in request header, as opposed to a relative path.
+      query = uri.join(query) if proxy
+
+      HTTP_REQUEST_HEADER % [method.to_s.upcase, query]
+    end
+
+    def encode_query(uri, query)
+      encoded_query = if query.kind_of?(Hash)
+        query.map { |k, v| encode_param(k, v) }.join('&')
+      else
+        query.to_s
+      end
+
+      if uri && !uri.query.to_s.empty?
+        encoded_query = [encoded_query, uri.query].reject {|part| part.empty?}.join("&")
+      end
+      encoded_query.to_s.empty? ? uri.path : "#{uri.path}?#{encoded_query}"
+    end
+
+    # URL encodes query parameters:
+    # single k=v, or a URL encoded array, if v is an array of values
+    def encode_param(k, v)
+      if v.is_a?(Array)
+        v.map { |e| escape(k) + "[]=" + escape(e) }.join("&")
+      else
+        escape(k) + "=" + escape(v)
+      end
+    end
+
+    def form_encode_body(obj)
+      pairs = []
+      recursive = Proc.new do |h, prefix|
+        h.each do |k,v|
+          key = prefix == '' ? escape(k) : "#{prefix}[#{escape(k)}]"
+
+          if v.is_a? Array
+            nh = Hash.new
+            v.size.times { |t| nh[t] = v[t] }
+            recursive.call(nh, key)
+
+          elsif v.is_a? Hash
+            recursive.call(v, key)
+          else
+            pairs << "#{key}=#{escape(v)}"
+          end
+        end
+      end
+
+      recursive.call(obj, '')
+      return pairs.join('&')
+    end
+
+    # Encode a field in an HTTP header
+    def encode_field(k, v)
+      FIELD_ENCODING % [k, v]
+    end
+
+    # Encode basic auth in an HTTP header
+    # In: Array ([user, pass]) - for basic auth
+    #     String - custom auth string (OAuth, etc)
+    def encode_auth(k,v)
+      if v.is_a? Array
+        FIELD_ENCODING % [k, ["Basic", Base64.encode64(v.join(":")).split.join].join(" ")]
+      else
+        encode_field(k,v)
+      end
+    end
+
+    def encode_headers(head)
+      head.inject('') do |result, (key, value)|
+        # Munge keys from foo-bar-baz to Foo-Bar-Baz
+        key = key.split('-').map { |k| k.to_s.capitalize }.join('-')
+        result << case key
+          when 'Authorization', 'Proxy-Authorization'
+            encode_auth(key, value)
+          else
+            encode_field(key, value)
+        end
+      end
+    end
+
+    def encode_cookie(cookie)
+      if cookie.is_a? Hash
+        cookie.inject('') { |result, (k, v)| result <<  encode_param(k, v) + ";" }
+      else
+        cookie
+      end
+    end
+  end
+end

data/lib/z-http/http_header.rb

@@ -0,0 +1,83 @@
+module ZMachine
+  # A simple hash is returned for each request made by HttpClient with the
+  # headers that were given by the server for that request.
+  class HttpResponseHeader < Hash
+    # The reason returned in the http response ("OK","File not found",etc.)
+    attr_accessor :http_reason
+
+    # The HTTP version returned.
+    attr_accessor :http_version
+
+    # The status code (as a string!)
+    attr_accessor :http_status
+
+    # Raw headers
+    attr_accessor :raw
+
+    # E-Tag
+    def etag
+      self[HttpClient::ETAG]
+    end
+
+    def last_modified
+      self[HttpClient::LAST_MODIFIED]
+    end
+
+    # HTTP response status as an integer
+    def status
+      @status ||= Integer(http_status) rescue 0
+    end
+
+    # Length of content as an integer, or nil if chunked/unspecified
+    def content_length
+      @content_length ||= ((s = self[HttpClient::CONTENT_LENGTH]) &&
+                           (s =~ /^(\d+)$/)) ? $1.to_i : nil
+    end
+
+    # Cookie header from the server
+    def cookie
+      self[HttpClient::SET_COOKIE]
+    end
+
+    # Is the transfer encoding chunked?
+    def chunked_encoding?
+      /chunked/i === self[HttpClient::TRANSFER_ENCODING]
+    end
+
+    def keepalive?
+      /keep-alive/i === self[HttpClient::KEEP_ALIVE]
+    end
+
+    def compressed?
+      /gzip|compressed|deflate/i === self[HttpClient::CONTENT_ENCODING]
+    end
+
+    def location
+      self[HttpClient::LOCATION]
+    end
+
+    def [](key)
+      super(key) || super(key.upcase.gsub('-','_'))
+    end
+
+    def informational?
+      100 <= status && 200 > status
+    end
+
+    def successful?
+      200 <= status && 300 > status
+    end
+
+    def redirection?
+      300 <= status && 400 > status
+    end
+
+    def client_error?
+      400 <= status && 500 > status
+    end
+
+    def server_error?
+      500 <= status && 600 > status
+    end
+  end
+end

data/lib/z-http/http_status_codes.rb

@@ -0,0 +1,57 @@
+module ZMachine
+  module HttpStatus
+    CODE = {
+      100  => 'Continue',
+      101  => 'Switching Protocols',
+      102  => 'Processing',
+      200  => 'OK',
+      201  => 'Created',
+      202  => 'Accepted',
+      203  => 'Non-Authoritative Information',
+      204  => 'No Content',
+      205  => 'Reset Content',
+      206  => 'Partial Content',
+      207  => 'Multi-Status',
+      226  => 'IM Used',
+      300  => 'Multiple Choices',
+      301  => 'Moved Permanently',
+      302  => 'Found',
+      303  => 'See Other',
+      304  => 'Not Modified',
+      305  => 'Use Proxy',
+      306  => 'Reserved',
+      307  => 'Temporary Redirect',
+      400  => 'Bad Request',
+      401  => 'Unauthorized',
+      402  => 'Payment Required',
+      403  => 'Forbidden',
+      404  => 'Not Found',
+      405  => 'Method Not Allowed',
+      406  => 'Not Acceptable',
+      407  => 'Proxy Authentication Required',
+      408  => 'Request Timeout',
+      409  => 'Conflict',
+      410  => 'Gone',
+      411  => 'Length Required',
+      412  => 'Precondition Failed',
+      413  => 'Request Entity Too Large',
+      414  => 'Request-URI Too Long',
+      415  => 'Unsupported Media Type',
+      416  => 'Requested Range Not Satisfiable',
+      417  => 'Expectation Failed',
+      422  => 'Unprocessable Entity',
+      423  => 'Locked',
+      424  => 'Failed Dependency',
+      426  => 'Upgrade Required',
+      500  => 'Internal Server Error',
+      501  => 'Not Implemented',
+      502  => 'Bad Gateway',
+      503  => 'Service Unavailable',
+      504  => 'Gateway Timeout',
+      505  => 'HTTP Version Not Supported',
+      506  => 'Variant Also Negotiates',
+      507  => 'Insufficient Storage',
+      510  => 'Not Extended'
+    }
+  end
+end

data/lib/z-http/middleware/digest_auth.rb

@@ -0,0 +1,112 @@
+module ZMachine
+  module Middleware
+    require 'digest'
+    require 'securerandom'
+
+    class DigestAuth
+      include ZMachine::HttpEncoding
+
+      attr_accessor :auth_digest, :is_digest_auth
+
+      def initialize(www_authenticate, opts = {})
+        @nonce_count = -1
+        @opts = opts
+        @digest_params = {
+            algorithm: 'MD5' # MD5 is the default hashing algorithm
+        }
+        if (@is_digest_auth = www_authenticate =~ /^Digest/)
+          get_params(www_authenticate)
+        end
+      end
+
+      def request(client, head, body)
+        # Allow HTTP basic auth fallback
+        if @is_digest_auth
+          head['Authorization'] = build_auth_digest(client.req.method, client.req.uri.path, @opts.merge(@digest_params))
+        else
+          head['Authorization'] = [@opts[:username], @opts[:password]]
+        end
+        [head, body]
+      end
+
+      def response(resp)
+        # If the server responds with the Authentication-Info header, set the nonce to the new value
+        if @is_digest_auth && (authentication_info = resp.response_header['Authentication-Info'])
+          authentication_info =~ /nextnonce="?(.*?)"?(,|\z)/
+          @digest_params[:nonce] = $1
+        end
+      end
+
+      def build_auth_digest(method, uri, params = nil)
+        params = @opts.merge(@digest_params) if !params
+        nonce_count = next_nonce
+
+        user = unescape params[:username]
+        password = unescape params[:password]
+
+        splitted_algorithm = params[:algorithm].split('-')
+        sess = "-sess" if splitted_algorithm[1]
+        raw_algorithm = splitted_algorithm[0]
+        if %w(MD5 SHA1 SHA2 SHA256 SHA384 SHA512 RMD160).include? raw_algorithm
+          algorithm = eval("Digest::#{raw_algorithm}")
+        else
+          raise "Unknown algorithm: #{raw_algorithm}"
+        end
+        qop = params[:qop]
+        cnonce = make_cnonce if qop or sess
+        a1 = if sess
+          [
+            algorithm.hexdigest("#{params[:username]}:#{params[:realm]}:#{params[:password]}"),
+            params[:nonce],
+            cnonce,
+            ].join ':'
+        else
+          "#{params[:username]}:#{params[:realm]}:#{params[:password]}"
+        end
+        ha1 = algorithm.hexdigest a1
+        ha2 = algorithm.hexdigest "#{method}:#{uri}"
+
+        request_digest = [ha1, params[:nonce]]
+        request_digest.push(('%08x' % @nonce_count), cnonce, qop) if qop
+        request_digest << ha2
+        request_digest = request_digest.join ':'
+        header = [
+          "Digest username=\"#{params[:username]}\"",
+          "realm=\"#{params[:realm]}\"",
+          "algorithm=#{raw_algorithm}#{sess}",
+          "uri=\"#{uri}\"",
+          "nonce=\"#{params[:nonce]}\"",
+          "response=\"#{algorithm.hexdigest(request_digest)[0, 32]}\"",
+        ]
+        if params[:qop]
+          header << "qop=#{qop}"
+          header << "nc=#{'%08x' % @nonce_count}"
+          header << "cnonce=\"#{cnonce}\""
+        end
+        header << "opaque=\"#{params[:opaque]}\"" if params.key? :opaque
+        header.join(', ')
+      end
+
+      # Process the WWW_AUTHENTICATE header to get the authentication parameters
+      def get_params(www_authenticate)
+        www_authenticate.scan(/(\w+)="?(.*?)"?(,|\z)/).each do |match|
+          @digest_params[match[0].to_sym] = match[1]
+        end
+      end
+
+      # Generate a client nonce
+      def make_cnonce
+        Digest::MD5.hexdigest [
+          Time.now.to_i,
+          $$,
+          SecureRandom.random_number(2**32),
+        ].join ':'
+      end
+
+      # Keep track of the nounce count
+      def next_nonce
+        @nonce_count += 1
+      end
+    end
+  end
+end

data/lib/z-http/middleware/json_response.rb

@@ -0,0 +1,15 @@
+require 'multi_json'
+
+module ZMachine
+  module Middleware
+    class JSONResponse
+      def response(resp)
+        begin
+          body = MultiJson.load(resp.response)
+          resp.response = body
+        rescue Exception => e
+        end
+      end
+    end
+  end
+end

data/lib/z-http/middleware/oauth.rb

@@ -0,0 +1,40 @@
+require 'simple_oauth'
+
+module ZMachine
+  module Middleware
+
+    class OAuth
+      include HttpEncoding
+
+      def initialize(opts = {})
+        @opts = opts.dup
+        # Allow both `oauth` gem and `simple_oauth` gem opts formats
+        @opts[:token] ||= @opts.delete(:access_token)
+        @opts[:token_secret] ||= @opts.delete(:access_token_secret)
+      end
+
+      def request(client, head, body)
+        request = client.req
+        uri     = request.uri.join(encode_query(request.uri, request.query))
+        params  = {}
+
+        # from https://github.com/oauth/oauth-ruby/blob/master/lib/oauth/request_proxy/em_http_request.rb
+        if ["POST", "PUT"].include?(request.method)
+          head["content-type"] ||= "application/x-www-form-urlencoded" if body.is_a? Hash
+          form_encoded = head["content-type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
+
+          if form_encoded
+            CGI.parse(client.normalize_body(body)).each do |k,v|
+              # Since `CGI.parse` always returns values as an array
+              params[k] = v.size == 1 ? v.first : v
+            end
+          end
+        end
+
+        head["Authorization"] = SimpleOAuth::Header.new(request.method, uri, params, @opts)
+
+        [head,body]
+      end
+    end
+  end
+end