uv-rays 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3800c7d8ef446765e933dbf2f732dd037d4185f2
+  data.tar.gz: 8cb367445a00f73ad52e16ab4d26dac7453c1cd6
+SHA512:
+  metadata.gz: a4812d336b5366a07b4ee4f77c888cc323a24d9f700c93ea0c0335aa7e18bc08918328ddeabd47b858ad2e6773c78ce9ebba6c4cb4a468bc449697dfd4b41b63
+  data.tar.gz: 07285a027794ac7f3d4332595f936ea56000b251909665e4dd02edeb5e77a7b6f74fe901617883199fd07332329c48bd03ea152db7fe40ec25bfe5515e831d48

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 CoTag Media
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,53 @@
+# uv-rays
+
+[![Build Status](https://travis-ci.org/cotag/uv-rays.png?branch=master)](https://travis-ci.org/cotag/uv-rays)
+
+UV-Rays was designed to eliminate the complexities of high-performance threaded network programming, allowing engineers to concentrate on their application logic.
+
+
+## Core Features
+
+1. TCP (and UDP) Connection abstractions
+2. Advanced stream tokenization
+3. Scheduled events (in, at, every, cron)
+4. HTTP 1.1 compatible client support
+
+This adds to the features already available from [Libuv](https://github.com/cotag/libuv) on which the gem is based
+
+
+## Support
+
+UV-Rays supports all platforms where ruby is available. Linux, OSX, BSD and Windows. MRI, jRuby and Rubinius.
+
+Run `gem install uv-rays` to install
+
+
+## Getting Started
+
+Here's a fully-functional echo server written with UV-Rays:
+
+```ruby
+
+ require 'uv-rays'
+
+ module EchoServer
+   def post_init
+     puts "-- someone connected to the echo server!"
+   end
+
+   def on_read data, *args
+     write ">>>you sent: #{data}"
+     close_connection if data =~ /quit/i
+   end
+
+   def on_close
+     puts "-- someone disconnected from the echo server!"
+   end
+end
+
+# Note that this will block current thread.
+Libuv::Loop.default.run {
+  UV.start_server "127.0.0.1", 8081, EchoServer
+}
+
+```

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rspec/core/rake_task'  # testing framework
+require 'yard'                  # yard documentation
+
+
+
+# By default we don't run network tests
+task :default => :limited_spec
+RSpec::Core::RakeTask.new(:limited_spec) do |t|
+    # Exclude network tests
+    # t.rspec_opts = "--tag ~network" 
+end
+RSpec::Core::RakeTask.new(:spec)
+
+
+desc "Run all tests"
+task :test => [:spec]
+
+
+YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb', '-', 'ext/README.md', 'README.md']
+end

data/lib/uv-rays/abstract_tokenizer.rb

@@ -0,0 +1,100 @@
+
+module UvRays
+
+    # AbstractTokenizer is similar to BufferedTokernizer however should
+    # only be used when there is no delimiter to work with. It uses a
+    # callback based system for application level tokenization without
+    # the heavy lifting.
+    class AbstractTokenizer
+
+        attr_accessor :callback, :indicator, :size_limit, :verbose
+
+        # @param [Hash] options
+        def initialize(options)
+            @callback  = options[:callback]
+            @indicator  = options[:indicator]
+            @size_limit = options[:size_limit]
+            @verbose  = options[:verbose] if @size_limit
+
+            raise ArgumentError, 'no indicator provided' unless @indicator
+            raise ArgumentError, 'no callback provided' unless @callback
+
+            @input = ''
+        end
+
+        # Extract takes an arbitrary string of input data and returns an array of
+        # tokenized entities using a message start indicator
+        #
+        # @example
+        #
+        #     tokenizer.extract(data).
+        #         map { |entity| Decode(entity) }.each { ... }
+        #
+        # @param [String] data
+        def extract(data)
+            @input << data
+
+            messages = @input.split(@indicator, -1)
+            if messages.length > 1
+                messages.shift      # the first item will always be junk
+                last = messages.pop # the last item may require buffering
+
+                entities = []
+                messages.each do |msg|
+                    entities << msg if @callback.call(msg)
+                end
+
+                # Check if buffering is required
+                result = @callback.call(last)
+                if result
+                    # Check for multi-byte indicator edge case
+                    if result.is_a? Fixnum
+                        entities << last[0...result]
+                        @input = last[result..-1]
+                    else
+                        @input = ''
+                        entities << last
+                    end
+                else
+                    # This will work with a regex
+                    index = messages.last.nil? ? 0 : @input[0...-last.length].rindex(messages.last) + messages.last.length
+                    indicator_val = @input[index...-last.length]
+                    @input = indicator_val + last
+                end
+            else
+                @input = messages.pop
+                entities = messages
+            end
+
+            # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+            if @size_limit && @input.size > @size_limit
+                if @indicator.respond_to?(:length) # check for regex
+                    # save enough of the buffer that if one character of the indicator were
+                    # missing we would match on next extract (very much an edge case) and
+                    # best we can do with a full buffer.
+                    @input = @input[-(@indicator.length - 1)..-1]
+                else
+                    @input = ''
+                end
+                raise 'input buffer exceeded limit' if @verbose
+            end
+
+            return entities
+        end
+
+        # Flush the contents of the input buffer, i.e. return the input buffer even though
+        # a token has not yet been encountered.
+        #
+        # @return [String]
+        def flush
+            buffer = @input
+            @input = ''
+            buffer
+        end
+
+        # @return [Boolean]
+        def empty?
+            @input.empty?
+        end
+    end
+end

data/lib/uv-rays/buffered_tokenizer.rb

@@ -0,0 +1,97 @@
+
+# BufferedTokenizer takes a delimiter upon instantiation.
+# It allows input to be spoon-fed from some outside source which receives
+# arbitrary length datagrams which may-or-may-not contain the token by which
+# entities are delimited.
+#
+# @example Using BufferedTokernizer to parse lines out of incoming data
+#
+#     module LineBufferedConnection
+#         def receive_data(data)
+#             (@buffer ||= BufferedTokenizer.new(delimiter: "\n")).extract(data).each do |line|
+#                 receive_line(line)
+#             end
+#         end
+#     end
+module UvRays
+    class BufferedTokenizer
+
+        attr_accessor :delimiter, :indicator, :size_limit, :verbose
+
+        # @param [Hash] options
+        def initialize(options)
+            @delimiter  = options[:delimiter]
+            @indicator  = options[:indicator]
+            @size_limit = options[:size_limit]
+            @verbose  = options[:verbose] if @size_limit
+
+            raise ArgumentError, 'no delimiter provided' unless @delimiter
+
+            @input = ''
+        end
+
+        # Extract takes an arbitrary string of input data and returns an array of
+        # tokenized entities, provided there were any available to extract.
+        #
+        # @example
+        #
+        #     tokenizer.extract(data).
+        #         map { |entity| Decode(entity) }.each { ... }
+        #
+        # @param [String] data
+        def extract(data)
+            @input << data
+
+            # Extract token-delimited entities from the input string with the split command.
+            # There's a bit of craftiness here with the -1 parameter.    Normally split would
+            # behave no differently regardless of if the token lies at the very end of the
+            # input buffer or not (i.e. a literal edge case)    Specifying -1 forces split to
+            # return "" in this case, meaning that the last entry in the list represents a
+            # new segment of data where the token has not been encountered
+            messages = @input.split(@delimiter, -1)
+
+            if @indicator
+                @input = messages.pop
+                entities = []
+                messages.each do |msg|
+                    res = msg.split(@indicator, -1)
+                    entities << res.last if res.length > 1
+                end
+            else
+                entities = messages
+                @input = entities.pop
+            end
+
+            # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+            if @size_limit && @input.size > @size_limit
+                if @indicator && @indicator.respond_to?(:length) # check for regex
+                    # save enough of the buffer that if one character of the indicator were
+                    # missing we would match on next extract (very much an edge case) and
+                    # best we can do with a full buffer. If we were one char short of a
+                    # delimiter it would be unfortunate
+                    @input = @input[-(@indicator.length - 1)..-1]
+                else
+                    @input = ''
+                end
+                raise 'input buffer exceeded limit' if @verbose
+            end
+
+            return entities
+        end
+
+        # Flush the contents of the input buffer, i.e. return the input buffer even though
+        # a token has not yet been encountered.
+        #
+        # @return [String]
+        def flush
+            buffer = @input
+            @input = ''
+            buffer
+        end
+
+        # @return [Boolean]
+        def empty?
+            @input.empty?
+        end
+    end
+end

data/lib/uv-rays/connection.rb

@@ -0,0 +1,175 @@
+
+module UvRays
+    def self.try_connect(tcp, handler, server, port)
+        if IPAddress.valid? server
+            tcp.finally handler.method(:on_close)
+            tcp.progress handler.method(:on_read)
+            tcp.connect server, port do
+                tcp.enable_nodelay
+                tcp.start_tls(handler.using_tls) unless handler.using_tls == false
+
+                # on_connect could call use_tls so must come after start_tls
+                handler.on_connect(tcp)
+                tcp.start_read
+            end
+        else
+            tcp.loop.lookup(server).then(
+                proc { |result|
+                    UvRays.try_connect(tcp, handler, result[0][0], port)
+                },
+                proc { |failure|
+                    # TODO:: Log error on loop
+                    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)
+        end
+
+        def close_connection(after_writing = false)
+            if after_writing
+                @transport.shutdown
+            else
+                @transport.close
+            end
+        end
+
+        def stream_file(filename)
+        end
+
+        def on_connect(transport) # user to define
+        end
+
+        def on_close # user to define
+        end
+    end
+
+    class InboundConnection < TcpConnection
+        def initialize(tcp)
+            super()
+
+            @loop = tcp.loop
+            @transport = tcp
+            @transport.finally method(:on_close)
+            @transport.progress method(:on_read)
+        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()
+
+            @loop = Libuv::Loop.current
+            @server = server
+            @port = port
+            @transport = @loop.tcp
+
+            ::UvRays.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)
+            @loop = Libuv::Loop.current || @loop
+
+            @transport = @loop.tcp
+            @server = server || @server
+            @port = port || @port
+
+            ::UvRays.try_connect(@transport, self, @server, @port)
+        end
+    end
+
+    class DatagramConnection < Connection
+        def initialize(server = nil, port = nil)
+            super()
+
+            @loop = Libuv::Loop.current
+            @transport = @loop.udp
+            @transport.progress method(:on_read)
+
+            if not server.nil?
+                server = '127.0.0.1' if server == 'localhost'
+                if IPAddress.valid? server
+                    @transport.bind(server, port)
+                else
+                    raise ArgumentError, "Invalid server address #{server}"
+                end
+            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
+                tcp.loop.lookup(server).then do |result|
+                    @transport.send result[0][0], recipient_port, data
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,119 @@
+module UvRays
+    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
+
+            # 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)
+
+                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.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
+end