Changeset 587

Timestamp:

11/26/07 16:40:43 (1 year ago)

Author:

blackhedd

Message:

development work on a replacement for the HTTP client.

Files:

• version_0/lib/protocols/httpcli2.rb (modified) (2 diffs)
• version_0/tests/test_httpclient2.rb (modified) (2 diffs)

version_0/lib/protocols/httpcli2.rb

@@ -25 +25 @@
-
-
+
-module EventMachine
-module Protocols
-
+
-        class HttpClient2 < Connection
+                include LineText2
+
+
+                class Request
+                        include Deferrable
+
+                        attr_reader :version
+                        attr_reader :status
+                        attr_reader :header_lines
+                        attr_reader :headers
+                        attr_reader :content
+                        attr_reader :internal_error
+
+                        def initialize conn, args
+                                @conn = conn
+                                @args = args
+                                @header_lines = []
+                                @headers = {}
+                                @blanks = 0
+                        end
+
+                        def send_request
+                                az = @args[:authorization] and az = "Authorization: #{az}\r\n"
+
+                                r = [
+                                        "#{@args[:verb]} #{@args[:uri]} HTTP/#{@args[:version] || "1.1"}\r\n",
+                                        "Host: #{@args[:host_header] || "_"}\r\n",
+                                        az || "",
+                                        "\r\n"
+                                ]
+                                @conn.send_data r.join
+                        end
+
+                        #--
+                        # Allow up to ten blank lines before we get a real response line.
+                        # Allow no more than 100 lines in the header.
+                        #
+                        def receive_line ln
+                                if ln.length == 0
+                                        if @header_lines.length > 0
+                                                process_header
+                                        else
+                                                @blanks += 1
+                                                if @blanks > 10
+                                                        @conn.close_connection
+                                                end
+                                        end
+                                else
+                                        @header_lines << ln
+                                        if @header_lines.length > 100
+                                                @internal_error = :bad_header
+                                                @conn.close_connection
+                                        end
+                                end
+                        end
+
+
+                        #--
+                        #
+                        #
+                        HttpResponseRE = /\AHTTP\/(1.[01]) ([\d]{3})/i
+                        ClenRE = /\AContent-length:\s*(\d+)/i
+                        ColonRE = /\:\s*/
+
+                        def process_header
+                                unless @header_lines.first =~ HttpResponseRE
+                                        @conn.close_connection
+                                        @internal_error = :bad_request
+                                end
+                                @version = $1.dup
+                                @status = $2.dup.to_i
+
+                                clen = nil
+                                @header_lines.each_with_index do |e,ix|
+                                        if ix > 0
+                                                hdr,val = e.split(ColonRE)
+                                                (@headers[hdr.downcase] ||= []) << val
+                                        end
+                                        if clen == nil and e =~ ClenRE
+                                                clen = $1.dup.to_i
+                                        end
+                                end
+
+                                if clen
+                                        @conn.set_text_mode clen
+                                else
+                                        # Chunked transfer, multipart, or end-of-connection.
+                                        # For end-of-connection, we need to go the unbind
+                                        # method and suppress its desire to fail us.
+                                        p "NO CLEN"
+                                        @internal_error = :unsupported_clen
+                                        @conn.close_connection
+                                end
+                        end
+                        private :process_header
+
+                        #--
+                        # At the present time, we only handle contents that have a length
+                        # specified by the content-length header.
+                        #
+                        def receive_text text
+                                @content = text
+                                @conn.pop_request
+                                succeed self
+                        end
+                end
+
+                # Make a connection to a remote HTTP server.
+                # Can take either a pair of arguments (which will be interpreted as
+                # a hostname/ip-address and a port), or a hash.
+                # If the arguments are a hash, then supported values include:
+                #  :host => a hostname or ip-address;
+                #  :port => a port number
+                #--
+                # TODO, support optional encryption arguments like :ssl
+                def self.connect *args
+                        if args.length == 2
+                                args = {:host=>args[0], :port=>args[1]}
+                        else
+                                args = args.first
+                        end
+
+                        h,prt,ssl = args[:host], Integer(args[:port]), (args[:tls] || args[:ssl])
+                        conn = EM.connect( h, prt, self )
+                        # TODO, start_tls if necessary
+                        conn.set_default_host_header( h, prt, ssl )
+                        conn
+                end
+
+
+                #--
+                # Compute and remember a string to be used as the host header in HTTP requests
+                # unless the user overrides it with an argument to #request.
+                #
+                def set_default_host_header host, port, ssl
+                        if (ssl and port != 443) or (!ssl and port != 80)
+                                @host_header = "#{host}:#{port}"
+                        else
+                                @host_header = host
+                        end
+                end
+
+
+                def post_init
+                        super
+                        @connected = EM::DefaultDeferrable.new
+                end
+
+                def connection_completed
+                        super
+                        @connected.succeed
+                end
+
+                #--
+                # All pending requests, if any, must fail.
+                # We might come here without ever passing through connection_completed
+                # in case we can't connect to the server. We'll also get here when the
+                # connection closes (either because the server closes it, or we close it
+                # due to detecting an internal error or security violation).
+                # In either case, run down all pending requests, if any, and signal failure
+                # on them.
+                #
+                # Set and remember a flag (@closed) so we can immediately fail any
+                # subsequent requests.
+                #
+                def unbind
+                        super
+                        @closed = true
+                        (@requests || []).each {|r| r.fail r}
+                end
+
+
+                def get args
+                        if args.is_a?(String)
+                                args = {:uri=>args}
+                        end
+                        args[:verb] = "GET"
+                        request args
+                end
+
+                def request args
+                        args[:host_header] = @host_header unless args.has_key?(:host_header)
+                        r = Request.new self, args
+                        if @closed
+                                r.fail
+                        else
+                                (@requests ||= []).unshift r
+                                @connected.callback {r.send_request}
+                        end
+                        r
+                end
+
+                def receive_line ln
+                        @requests.last.receive_line ln
+                end
+                def receive_binary_data text
+                        @requests.last.receive_text text
+                end
+
+                #--
+                # Called by a Request object when it completes.
+                #
+                def pop_request
+                        @requests.pop
+                end
+        end
+
+
+=begin
+        class HttpClient2x < Connection
-                include LineText2
-
@@ -253 +465 @@
-
-        end
+=end
-end
-end

version_0/tests/test_httpclient2.rb

@@ -67 +67 @@
-        end
-
+        def test_bad_server
+                EM.run {
+                        http = EM::P::HttpClient2.connect Localhost, 9999
+                        d = http.get "/"
+                        d.errback {|r| p r.internal_error; EM.stop }
+                }
+        end
+
-        def test_get
-                EM.run {
-                        EM.start_server Localhost, Localport, TestServer
-                        http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
-                        d = http.get "/"
-                        d.callback {|resp|
+                                p resp.content
+                                EM.stop
+                        }
+                }
+        end
+
+        # Not a pipelined request because we wait for one response before we request the next.
+        def test_get_multiple
+                EM.run {
+                        http = EM::P::HttpClient2.connect "www.bayshorenetworks.com", 80
+                        d = http.get "/"
+                        d.callback {|r|
-                                e = http.get "/"
-
-
+
+
+
-                                }
-                        }
@@ -81 +101 @@
-        end
-
+        def test_get_pipeline
+                EM.run {
+                        http = EM::P::HttpClient2.connect "www.microsoft.com", 80
+                        http.get("/").callback {|r|
+                                p r.headers
+                        }
+                        http.get("/").callback {|r|
+                                p r.headers
+                        }
+                        EM::Timer.new(1) {EM.stop}
+                }
+        end
+
+
+        def test_authheader
+                EM.run {
+                        EM.start_server Localhost, Localport, TestServer
+                        http = EM::P::HttpClient2.connect Localhost, 18842
+                        d = http.get :url=>"/", :authorization=>"Basic xxx"
+                        d.callback {|r| EM.stop}
+                        d.errback {|r| EM.stop}
+                }
+        end
+
+
-end
-