uv-rays 0.0.1

data/lib/uv-rays/http/request.rb

@@ -0,0 +1,150 @@
+module UvRays
+    module Http
+        class Request < ::Libuv::Q::DeferredPromise
+            include Encoding
+
+
+            COOKIE = 'cookie'
+            CONNECTION = :Connection
+            CRLF="\r\n"
+
+
+            attr_reader :path
+            attr_reader :method
+
+
+            def cookies_hash
+                @endpoint.cookiejar.get_hash(@uri)
+            end
+
+            def set_cookie(value)
+                @endpoint.cookiejar.set(@uri, value)
+            end
+            
+
+            def initialize(endpoint, options)
+                super(endpoint.loop, endpoint.loop.defer)
+
+                @options = options
+                @endpoint = endpoint
+
+                @path = options[:path]
+                @method = options[:method]
+                @uri = encode_host(endpoint.host, endpoint.port) + @path
+            end
+
+            def resolve(response)
+                @defer.resolve({
+                    headers: @headers,
+                    body: response
+                })
+            end
+
+            def reject(reason)
+                @defer.reject(reason)
+            end
+
+            def send(transport, error)
+                head, body = build_request, @options[:body]
+
+                @endpoint.middleware.each do |m|
+                    head, body = m.request(self, head, body) if m.respond_to?(:request)
+                end
+
+                body = body.is_a?(Hash) ? form_encode_body(body) : body
+                file = @options[:file]
+                query = @options[:query]
+
+                # Set the Content-Length if file is given
+                head['content-length'] = File.size(file) if file
+
+                # Set the Content-Length if body is given,
+                # or we're doing an empty post or put
+                if body
+                    head['content-length'] = body.bytesize
+                elsif method == :post or method == :put
+                    # wont happen if body is set and we already set content-length above
+                    head['content-length'] ||= 0
+                end
+
+                # Set content-type header if missing and body is a Ruby hash
+                if !head['content-type'] and @options[:body].is_a? Hash
+                    head['content-type'] = 'application/x-www-form-urlencoded'
+                end
+
+                request_header = encode_request(method, path, query)
+                request_header << encode_headers(head)
+                request_header << CRLF
+
+                transport.write(request_header).catch error
+
+                if body
+                    transport.write(body).catch error
+                elsif file
+                    # TODO:: Send file
+                    #@conn.stream_file_data @req.file, :http_chunks => false
+                end
+            end
+
+            def notify(*args)
+                @defer.notify(*args)
+            end
+
+            def set_headers(head)
+                @headers = head
+                if not @headers_callback.nil?
+                    @headers_callback.call(@headers)
+                end
+            end
+
+            def headers(callback, &blk)
+                callback ||= blk
+                if @headers.nil?
+                    @headers_callback = callback
+                else
+                    callback.call(@headers)
+                end
+            end
+
+
+            protected
+
+
+            def encode_host(host, port)
+                if port.nil? || port == 80 || port == 443
+                    host
+                else
+                    host + ":#{port}"
+                end
+            end
+
+            def build_request
+                head = @options[:headers] ? munge_header_keys(@options[:headers]) : {}
+
+                # Set the cookie header if provided
+                @cookies = @endpoint.cookiejar.get(@uri)
+                if cookie = head[COOKIE]
+                    @cookies << encode_cookie(cookie)
+                end
+                head[COOKIE] = @cookies.compact.uniq.join("; ").squeeze(";") unless @cookies.empty?
+
+                # Set connection close unless keep-alive
+                if !@options[:keepalive]
+                    head['connection'] = 'close'
+                end
+
+                # Set the Host header if it hasn't been specified already
+                head['host'] ||= encode_host(@endpoint.host, @endpoint.port)
+
+                # Set the User-Agent if it hasn't been specified
+                if !head.key?('user-agent')
+                    head['user-agent'] = "UvRays HttpClient"
+                elsif head['user-agent'].nil?
+                    head.delete('user-agent')
+                end
+
+                head
+            end
+        end
+    end
+end

data/lib/uv-rays/http/response.rb

@@ -0,0 +1,119 @@
+module UvRays
+    module Http
+        class Headers < Hash
+            # The HTTP version returned
+            attr_accessor :http_version
+
+            # The status code (as an integer)
+            attr_accessor :status
+
+            # Cookies at the time of the request
+            attr_accessor :cookies
+
+            attr_accessor :keep_alive
+        end
+
+        class Response
+            def initialize(requests)
+                @requests = requests
+
+                @parser = ::HttpParser::Parser.new(self)
+                @state = ::HttpParser::Parser.new_instance
+                @state.type = :response
+            end
+
+            # Called on connection disconnect
+            def reset!
+                @state.reset!
+            end
+
+            # Socket level data is forwarded as it arrives
+            def receive(data)
+                # Returns true if error
+                if @parser.parse(@state, data)
+                    if @request
+                        @request.reject(@state.error)
+                        return true
+                    #else # silently fail here
+                    #    p 'parse error and no request..'
+                    #    p @state.error
+                    end
+                end
+
+                false
+            end
+
+            ##
+            # Parser Callbacks:
+            def on_message_begin(parser)
+                @request = @requests.shift
+                @headers = Headers.new
+                @body = ''
+                @chunked = false
+            end
+
+            def on_status_complete(parser)
+                # Different HTTP versions have different defaults
+                if @state.http_minor == 0
+                    @close_connection = true
+                else
+                    @close_connection = false
+                end
+            end
+
+            def on_header_field(parser, data)
+                @header = data.to_sym
+            end
+
+            def on_header_value(parser, data)
+                case @header
+                when :"Set-Cookie"
+                    @request.set_cookie(data)
+
+                when :Connection
+                    # Overwrite the default
+                    @close_connection = data == 'close'
+
+                when :"Transfer-Encoding"
+                    # If chunked we'll buffer streaming data for notification
+                    @chunked = data == 'chunked'
+
+                else
+                    @headers[@header] = data
+                end
+            end
+
+            def on_headers_complete(parser)
+                headers = @headers
+                @headers = nil
+                @header = nil
+
+                # https://github.com/joyent/http-parser indicates we should extract
+                # this information here
+                headers.http_version = @state.http_version
+                headers.status = @state.http_status
+                headers.cookies = @request.cookies_hash
+                headers.keep_alive = !@close_connection
+
+                # User code may throw an error
+                # Errors will halt the processing and return a PAUSED error
+                @request.set_headers(headers)
+            end
+
+            def on_body(parser, data)
+                @body << data
+                # TODO:: What if it is a chunked response body?
+                # We should buffer complete chunks
+                @request.notify(data)
+            end
+
+            def on_message_complete(parser)
+                @request.resolve(@body)
+
+                # Clean up memory
+                @request = nil
+                @body = nil
+            end
+        end
+    end
+end

data/lib/uv-rays/http_endpoint.rb

@@ -0,0 +1,253 @@
+module UvRays
+    class CookieJar
+        def initialize
+            @jar = ::CookieJar::Jar.new
+        end
+
+        def set(string, uri)
+            @jar.set_cookie(uri, string) rescue nil # drop invalid cookies
+        end
+
+        def get(uri)
+            uri = URI.parse(uri) rescue nil
+            uri ? @jar.get_cookies(uri).map(&:to_s) : []
+        end
+
+        def get_hash(uri)
+            uri = URI.parse(uri) rescue nil
+            cookies = {}
+            if uri
+                @jar.get_cookies(uri).each do |cookie|
+                    cookies[cookie.name.to_sym] = cookie.value
+                end
+            end
+            cookies
+        end
+    end # CookieJar
+
+
+    class HttpEndpoint < TcpConnection
+        TRANSFER_ENCODING="TRANSFER_ENCODING"
+        CONTENT_ENCODING="CONTENT_ENCODING"
+        CONTENT_LENGTH="CONTENT_LENGTH"
+        CONTENT_TYPE="CONTENT_TYPE"
+        LAST_MODIFIED="LAST_MODIFIED"
+        KEEP_ALIVE="CONNECTION"
+        LOCATION="LOCATION"
+        HOST="HOST"
+        ETAG="ETAG"
+        CRLF="\r\n"
+
+
+        @@defaults = {
+            :path => '/',
+            :keepalive => true
+        }
+
+        attr_reader :host, :port, :using_tls, :loop, :cookiejar
+        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
+
+
+            @using_tls = options[:tls] || options[:ssl] || false
+            @using_tls.delete(:server) unless @using_tls == false
+
+            uri = uri.kind_of?(Addressable::URI) ? uri : Addressable::URI::parse(uri.to_s)
+            @https = uri.scheme == "https"
+            uri.port ||= (@https ? 443 : 80)
+
+
+            @loop = Libuv::Loop.current
+            @host = uri.host
+            @port = uri.port
+            #@transport = @loop.tcp
+
+            # State flags
+            @ready = false
+            @connecting = false
+
+            # Current requests
+            @pending_requests = []
+            @pending_responses = []
+            @connection_pending = []
+            @cookiejar = CookieJar.new
+
+            # Callback methods
+            @connection_method = method(:get_connection)
+            @next_request_method = method(:next_request)
+            @idle_timeout_method = method(:idle_timeout)
+            @connect_timeout_method = method(:connect_timeout)
+
+            # Used to indicate when we can start the next send
+            @breakpoint = ::Libuv::Q::ResolvedPromise.new(@loop, true)
+
+            # Manages the tokenising of response from the input stream
+            @response = Http::Response.new(@pending_responses)
+
+            # Timeout timer
+            if @connect_timeout || @inactivity_timeout
+                @timer = @loop.timer
+            end
+        end
+
+
+        def get      options = {}, &blk;  request(:get,     options, &blk); end
+        def head     options = {}, &blk;  request(:head,    options, &blk); end
+        def delete   options = {}, &blk;  request(:delete,  options, &blk); end
+        def put      options = {}, &blk;  request(:put,     options, &blk); end
+        def post     options = {}, &blk;  request(:post,    options, &blk); end
+        def patch    options = {}, &blk;  request(:patch,   options, &blk); end
+        def options  options = {}, &blk;  request(:options, options, &blk); end
+
+
+        def request(method, options = {}, &blk)
+            options = @@defaults.merge(options)
+            options[:method] = method
+
+            # Setup the request with callbacks
+            request = Http::Request.new(self, options)
+            request.then proc { |result|
+                if !result[:headers].keep_alive
+                    @transport.close
+                end
+                result
+            }
+
+            ##
+            # TODO:: Add middleware here
+            request.then blk if blk
+
+            # Add to pending requests and schedule using the breakpoint
+            @pending_requests << request
+            @breakpoint.finally @next_request_method
+            if options[:pipeline] == true
+                options[:keepalive] = true
+            else
+                @breakpoint = request
+            end
+
+            # return the request
+            request
+        end
+
+        def middleware
+            # TODO:: allow for middle ware
+            []
+        end
+
+        def on_read(data, *args)
+            @timer.again if @inactivity_timeout > 0
+            # returns true on error
+            # Response rejects the request
+            if @response.receive(data)
+                @transport.close
+            end
+        end
+
+        def on_close
+            @ready = false
+            @connecting = false
+            stop_timer
+
+            # Reject any requests waiting on a response
+            @pending_responses.each do |request|
+                request.reject(:disconnected)
+            end
+            @pending_responses.clear
+            
+            # Re-connect if there are pending requests
+            if not @connection_pending.empty?
+                do_connect
+            end
+        end
+
+        def on_connect(transport)
+            @connecting = false
+            @ready = true
+
+            # Update timeouts
+            stop_timer
+            if @inactivity_timeout > 0
+                @timer.progress @idle_timeout_method
+                @timer.start @inactivity_timeout * 1000
+            end
+
+            # Kick off pending requests
+            @response.reset!
+            @connection_pending.each do |callback|
+                callback.call
+            end
+            @connection_pending.clear
+        end
+
+
+        protected
+
+
+        def do_connect
+            @transport = @loop.tcp
+
+            if @connect_timeout > 0
+                @timer.progress @connect_timeout_method
+                @timer.start @connect_timeout * 1000
+            end
+
+            @connecting = true
+            ::UvRays.try_connect(@transport, self, @host, @port)
+        end
+
+        def get_connection(callback = nil, &blk)
+            callback ||= blk
+
+            if @connecting
+                @connection_pending << callback
+            elsif !@ready
+                @connection_pending << callback
+                do_connect
+            elsif @transport.closing?
+                @connection_pending << callback
+            else
+                callback.call(@connection)
+            end
+        end
+
+        def connect_timeout
+            @timer.stop
+            @transport.close
+            @connection_pending.each do |request|
+                request.reject(:connection_timeout)
+            end
+        end
+
+        def idle_timeout
+            @timer.stop
+            @transport.close
+            @pending_responses.each do |request|
+                request.reject(:idle_timeout)
+            end
+        end
+
+        def next_request
+            request = @pending_requests.shift
+
+            get_connection do
+                @pending_responses << request
+
+                @timer.again if @inactivity_timeout > 0
+
+                # TODO:: have request deal with the error internally
+                request.send(@transport, proc { |err|
+                    @transport.close
+                    request.reject(err)
+                })
+            end
+        end
+
+        def stop_timer
+            @timer.stop unless @timer.nil?
+        end
+    end
+end