mt-uv-rays 2.4.7

data/lib/mt-uv-rays/connection.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'ipaddress' # IP Address parser
+
+module MTUV
+    def self.try_connect(tcp, handler, server, port)
+        if IPAddress.valid? server
+            tcp.finally { handler.on_close }
+            tcp.progress { |*data| handler.on_read(*data) }
+            tcp.connect server, port do
+                tcp.enable_nodelay
+                tcp.start_tls(handler.using_tls) if handler.using_tls
+
+                # on_connect could call use_tls so must come after start_tls
+                handler.on_connect(tcp)
+                tcp.start_read
+            end
+        else
+            tcp.reactor.lookup(server, wait: false).then(
+                proc { |result|
+                    MTUV.try_connect(tcp, handler, result[0][0], port)
+                },
+                proc { |failure|
+                    # TODO:: Log error on reactor
+                    handler.on_close
+                }
+            )
+        end
+    end
+
+
+    # @abstract
+    class Connection
+        attr_reader :using_tls
+
+        def initialize
+            @send_queue = []
+            @paused = false
+            @using_tls = false
+        end
+
+        def pause
+            @paused = true
+            @transport.stop_read
+        end
+
+        def paused?
+            @paused
+        end
+
+        def resume
+            @paused = false
+            @transport.start_read
+        end
+
+        # Compatible with TCP
+        def close_connection(*args)
+            @transport.close
+        end
+
+        def on_read(data, *args) # user to define
+        end
+
+        def post_init(*args)
+        end
+    end
+
+    class TcpConnection < Connection
+        def write(data)
+            @transport.write(data, wait: :promise)
+        end
+
+        def close_connection(after_writing = false)
+            if after_writing
+                @transport.shutdown
+            else
+                @transport.close
+            end
+        end
+
+        def stream_file(filename, type = :raw)
+            file = @reactor.file(filename, File::RDONLY) do    # File is open and available for reading
+                file.send_file(@transport, type, wait: :promise).finally do
+                    file.close
+                end
+            end
+            return file
+        end
+
+        def keepalive(raw_time)
+            time = raw_time.to_i
+            if time.to_i <= 0
+                @transport.disable_keepalive
+            else
+                @transport.enable_keepalive(time)
+            end
+        end
+
+        def on_connect(transport) # user to define
+        end
+
+        def on_close # user to define
+        end
+    end
+
+    class InboundConnection < TcpConnection
+        def initialize(tcp)
+            super()
+
+            @reactor = tcp.reactor
+            @transport = tcp
+            @transport.finally { on_close }
+            @transport.progress { |*data| on_read(*data) }
+        end
+
+        def use_tls(args = {})
+            args[:server] = true
+
+            if @transport.connected
+                @transport.start_tls(args)
+            else
+                @using_tls = args
+            end
+        end
+    end
+
+    class OutboundConnection < TcpConnection
+
+        def initialize(server, port)
+            super()
+
+            @reactor = reactor
+            @server = server
+            @port = port
+            @transport = @reactor.tcp
+
+            ::MTUV.try_connect(@transport, self, @server, @port)
+        end
+
+        def use_tls(args = {})
+            args.delete(:server)
+
+            if @transport.connected
+                @transport.start_tls(args)
+            else
+                @using_tls = args
+            end
+        end
+
+        def reconnect(server = nil, port = nil)
+            @reactor = reactor
+
+            @transport = @reactor.tcp
+            @server = server || @server
+            @port = port || @port
+
+            ::MTUV.try_connect(@transport, self, @server, @port)
+        end
+    end
+
+    class DatagramConnection < Connection
+        def initialize(server = nil, port = nil)
+            super()
+
+            @reactor = reactor
+            @transport = @reactor.udp
+            @transport.progress { |*args| on_read(*args) }
+
+            if not server.nil?
+                server = '127.0.0.1' if server == 'localhost'
+                raise ArgumentError, "Invalid server address #{server}" unless IPAddress.valid?(server)
+                @transport.bind(server, port)
+            end
+
+            @transport.start_read
+        end
+
+        def send_datagram(data, recipient_address, recipient_port)
+            if IPAddress.valid? recipient_address
+                @transport.send recipient_address, recipient_port, data
+            else
+                # Async DNS resolution
+                # Note:: send here will chain the promise
+                @reactor.lookup(recipient_address).then do |result|
+                    @transport.send result[0][0], recipient_port, data
+                end
+            end
+        end
+    end
+end

data/lib/mt-uv-rays/http/encoding.rb

@@ -0,0 +1,131 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+module MTUV
+    module Http
+        module Encoding
+            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_request(method, uri, query)
+                query = encode_query(uri, query)
+                String.new(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
+                encoded_query.to_s.empty? ? uri : "#{uri}?#{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.strict_encode64(v.join(":"))].join(" ")]
+                else
+                    encode_field(k, v)
+                end
+            end
+
+            def encode_headers(head)
+                head.inject(String.new) 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(String.new) { |result, (k, v)| result << encode_param(k, v) + ';' }
+                else
+                    cookie
+                end
+            end
+        end
+    end
+end

data/lib/mt-uv-rays/http/parser.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+
+module MTUV
+    module Http
+        class Headers < ::ActiveSupport::HashWithIndifferentAccess
+            # The HTTP version returned
+            attr_accessor :http_version
+
+            # The status code (as an integer)
+            attr_accessor :status
+
+            # The text after the status code
+            attr_accessor :reason_phrase
+
+            # Cookies at the time of the request
+            attr_accessor :cookies
+
+            attr_accessor :keep_alive
+
+            attr_accessor :body
+
+            def to_s
+                "HTTP#{http_version} #{status} - keep alive: #{keep_alive}\nheaders: #{super}\nbody: #{body}"
+            end
+
+            alias_method :inspect, :to_s
+        end
+
+        class Parser
+            def initialize
+                @parser = ::HttpParser::Parser.new(self)
+                @state = ::HttpParser::Parser.new_instance
+                @state.type = :response
+                @headers = nil
+            end
+
+
+            attr_reader :request
+
+
+            def new_request(request)
+                @headers = nil
+                @request = request
+                @headers_complete = false
+                @state.reset!
+            end
+
+            def received(data)
+                if @parser.parse(@state, data)
+                    if @request
+                        @request.reject(@state.error)
+                        @request = nil
+                        @response = nil
+                        return true
+                    end
+                end
+
+                false
+            end
+
+            ##
+            # Parser Callbacks:
+            def on_message_begin(parser)
+                @headers = Headers.new
+                @body = String.new
+                @chunked = false
+                @close_connection = false
+            end
+
+            def on_status(parser, data)
+                @headers.reason_phrase = data
+
+                # 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
+            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'
+
+                end
+
+                # Duplicate headers we'll place into an array
+                current = @headers[@header]
+                if current
+                    arr = @headers[@header] = Array(current)
+                    arr << data
+                else
+                    @headers[@header] = data
+                end
+            end
+
+            def on_headers_complete(parser)
+                @headers_complete = true
+
+                # 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)
+                if @request.streaming?
+                    @request.notify(data)
+                else
+                    @body << data
+                end
+            end
+
+            def on_message_complete(parser)
+                @headers.body = @body
+
+                if @request.resolve(@headers)
+                    cleanup
+                else
+                    req = @request
+                    cleanup
+                    new_request(req)
+                end
+            end
+
+            # We need to flush the response on disconnect if content-length is undefined
+            # As per the HTTP spec
+            attr_accessor :reason
+            def eof
+                return if @request.nil?
+
+                if @headers_complete && (@headers['Content-Length'].nil? || @request.method == :head)
+                    on_message_complete(nil)
+                else
+                    # Reject if this is a partial response
+                    @request.reject(@reason || :partial_response)
+                    cleanup
+                end
+            end
+
+
+            private
+
+
+            def cleanup
+                @request = nil
+                @body = nil
+                @headers = nil
+                @reason = nil
+                @headers_complete = false
+            end
+        end
+    end
+end