mt-uv-rays 2.4.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83172a1213c66ea2b83c177a7f7a374498d8167a286ce71bd829fc5786ccd0bb
+  data.tar.gz: 7b9b3620628d7587e06f38ac57bfc9aa7037d1442d3defdf0d6ba95d5cadebde
+SHA512:
+  metadata.gz: 2225d0202e4ff24e1da86b9be15c1d81baf01a00548006f557da22c3032c9486a0b78124bf2853a253c70f9aed538411fb8dbe2f0c7d3ed2987a5956d2d22caf
+  data.tar.gz: 4ce9366261183a0ab2699da88fc404e8d3c52ef9d7073180ebf7547e3f90cf940b256755d61c45c159f51e9954072e6b666ebcc665786e7ff46ef0d4dffe62bd

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,63 @@
+# uv-rays
+
+[![Build Status](https://travis-ci.org/cotag/uv-rays.svg?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 on_connect(socket)
+    @ip, @port = socket.peername
+    logger.info "-- #{@ip}:#{@port} connected"
+  end
+
+  def on_read(data, socket)
+    write ">>>you sent: #{data}"
+    close_connection if data =~ /quit/i
+  end
+
+  def on_close
+    puts "-- #{@ip}:#{@port} disconnected"
+  end
+end
+
+reactor {
+  UV.start_server "127.0.0.1", 8081, EchoServer
+}
+
+```
+
+# Integrations
+
+UV-Rays works with many existing GEMs by integrating into common HTTP abstraction libraries
+
+* [Faraday](https://github.com/lostisland/faraday)
+* [HTTPI](https://github.com/savonrb/httpi)
+* [Handsoap](https://github.com/unwire/handsoap)
+
+
+

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 ~mri_only --tag ~travis_skip"
+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/faraday/adapter/mt-libuv.rb

@@ -0,0 +1,89 @@
+require 'faraday'
+require 'mt-uv-rays'
+
+
+module Faraday
+  class Adapter < Middleware
+    register_middleware libuv: :MTLibuv
+
+    class MTLibuv < Faraday::Adapter
+      def initialize(app, connection_options = {})
+        @connection_options = connection_options
+        super(app)
+      end
+
+      def call(env)
+        super
+
+        opts = {}
+        if env[:url].scheme == 'https' && ssl = env[:ssl]
+          tls_opts = opts[:tls_options] = {}
+
+          # opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
+          # TODO:: Need to provide verify callbacks
+
+          tls_opts[:cert_chain] = ssl[:ca_path] if ssl[:ca_path]
+          tls_opts[:client_ca] = ssl[:ca_file] if ssl[:ca_file]
+          #tls_opts[:client_cert] = ssl[:client_cert] if ssl[:client_cert]
+          #tls_opts[:client_key]  = ssl[:client_key]  if ssl[:client_key]
+          #tls_opts[:certificate] = ssl[:certificate] if ssl[:certificate]
+          tls_opts[:private_key] = ssl[:private_key] if ssl[:private_key]
+        end
+
+        if (req = env[:request])
+          opts[:inactivity_timeout] = (req[:timeout] * 1000) if req[:timeout]
+        end
+
+        if proxy = env[:request][:proxy]
+          opts[:proxy] = {
+            host: proxy[:uri].host,
+            port: proxy[:uri].port,
+            username: proxy[:user],
+            password: proxy[:password]
+          }
+        end
+
+        error = nil
+        thread = reactor
+        if thread.running?
+          error = perform_request(env, opts)
+        else
+          # Pretty much here for testing
+          thread.run {
+            error = perform_request(env, opts)
+          }
+        end
+
+        # Re-raise the error out of the event loop
+        # Really this is only required for tests as this will always run on the reactor
+        raise error if error
+        @app.call env
+      rescue ::CoroutineRejection => err
+        if err.value == :timeout
+          raise Error::TimeoutError, err
+        else
+          raise Error::ConnectionFailed, err
+        end
+      end
+
+      # TODO: support streaming requests
+      def read_body(env)
+        env[:body].respond_to?(:read) ? env[:body].read : env[:body]
+      end
+    end
+
+    def perform_request(env, opts)
+      conn = ::UV::HttpEndpoint.new(env[:url].to_s, opts.merge!(@connection_options))
+      resp = conn.request(env[:method].to_s.downcase.to_sym,
+        headers: env[:request_headers],
+        path: "/#{env[:url].to_s.split('/', 4)[-1]}",
+        keepalive: false,
+        body: read_body(env)).value
+
+      save_response(env, resp.status.to_i, resp.body, resp) #, resp.reason_phrase)
+      nil
+    rescue Exception => e
+      e
+    end
+  end
+end

data/lib/handsoap/http/drivers/mt-libuv_driver.rb

@@ -0,0 +1,43 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+require 'handsoap'
+
+module Handsoap
+    module Http
+        module Drivers
+            class MTLibuvDriver < AbstractDriver
+                def self.load!
+                    require 'mt-uv-rays'
+                end
+
+                def send_http_request_async(request)
+                    endp = ::UV::HttpEndpoint.new(request.url)
+
+                    if request.username && request.password
+                        request.headers['Authorization'] = [request.username, request.password]
+                    end
+
+                    req = endp.request(request.http_method, {
+                        headers: request.headers,
+                        body: request.body
+                    })
+
+                    deferred = ::Handsoap::Deferred.new
+                    req.then do |resp|
+                        # Downcase headers and convert values to arrays
+                        headers = Hash[resp.map { |k, v| [k.to_s.downcase, Array(v)] }]
+                        http_response = parse_http_part(headers, resp.body, resp.status)
+                        deferred.trigger_callback http_response
+                    end
+                    req.catch do |err|
+                        deferred.trigger_errback err
+                    end
+                    deferred
+                end
+            end
+        end
+
+        @@drivers[:libuv] = ::Handsoap::Http::Drivers::MTLibuvDriver
+    end
+end

data/lib/httpi/adapter/mt-libuv.rb

@@ -0,0 +1,69 @@
+require 'httpi'
+
+module HTTPI; end
+module HTTPI::Adapter; end
+class HTTPI::Adapter::MTLibuv < HTTPI::Adapter::Base
+    register :mtlibuv, deps: %w(mt-uv-rays)
+
+    def initialize(request)
+        @request = request
+        @client = ::MTUV::HttpEndpoint.new request.url
+    end
+
+    attr_reader :client
+
+    def request(method)
+        @client.inactivity_timeout = (@request.read_timeout * 1000).to_i if @request.read_timeout && @request.read_timeout > 0
+
+        req = {
+            path: @request.url,
+            headers: @request.headers,
+            body: @request.body
+        }
+
+        if proxy = @request.proxy
+            req[:proxy] = {
+                host: proxy.host,
+                port: proxy.port,
+                username: proxy.user,
+                password: proxy.password
+            }
+        end
+
+        # Apply authentication settings
+        auth = @request.auth
+        type = auth.type
+        if auth.type
+            creds = auth.credentials
+
+            case auth.type
+            when :basic
+                req[:headers][:Authorization] = creds
+            when :digest
+                req[:digest] = {
+                    user: creds[0],
+                    password: creds[1]
+                }
+            when :ntlm
+                req[:ntlm] = {
+                    username: creds[0],
+                    password: creds[1],
+                    domain: creds[2] || ''
+                }
+            end
+        end
+
+        # Apply Client certificates
+        ssl = auth.ssl
+        if ssl.verify_mode == :peer
+            tls_opts = req[:tls_options] = {}
+            tls_opts[:cert_chain]  = ssl.cert.to_pem     if ssl.cert
+            tls_opts[:client_ca]   = ssl.ca_cert_file    if ssl.ca_cert_file
+            tls_opts[:private_key] = ssl.cert_key.to_pem if ssl.cert_key
+        end
+
+        # Use co-routines to make non-blocking requests
+        response = @client.request(method, req).value
+        ::HTTPI::Response.new(response.status, response, response.body)
+    end
+end

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

@@ -0,0 +1,121 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+module MTUV
+
+    # 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
+        DEFAULT_ENCODING = 'ASCII-8BIT'
+
+        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
+            @encoding   = options[:encoding] || DEFAULT_ENCODING
+
+            raise ArgumentError, 'no callback provided' unless @callback
+
+            reset
+            if @indicator.is_a?(String)
+                @indicator = String.new(@indicator).force_encoding(@encoding).freeze
+            end
+        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)
+            data.force_encoding(@encoding)
+            @input << data
+
+            entities = []
+
+            loop do
+                found = false
+
+                last = if @indicator
+                    check = @input.partition(@indicator)
+                    break unless check[1].length > 0
+
+                    check[2]
+                else
+                    @input
+                end
+
+                result = @callback.call(last)
+
+                if result
+                    found = true
+
+                    # Check for multi-byte indicator edge case
+                    case result
+                    when Integer
+                        entities << last[0...result]
+                        @input = last[result..-1]
+                    else
+                        entities << last
+                        reset
+                    end
+                end
+
+                break if not found
+            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
+                    reset
+                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
+            reset
+            buffer
+        end
+
+        # @return [Boolean]
+        def empty?
+            @input.empty?
+        end
+
+        # @return [Integer]
+        def bytesize
+            @input.bytesize
+        end
+
+
+        private
+
+
+        def reset
+            @input = String.new.force_encoding(@encoding)
+        end
+    end
+end

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

@@ -0,0 +1,176 @@
+# encoding: ASCII-8BIT
+# frozen_string_literal: true
+
+# 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 MTUV
+    class BufferedTokenizer
+        DEFAULT_ENCODING = 'ASCII-8BIT'
+
+        attr_accessor :delimiter, :indicator, :size_limit, :verbose
+
+        # @param [Hash] options
+        def initialize(options)
+            @delimiter  = options[:delimiter]
+            @indicator  = options[:indicator]
+            @msg_length = options[:msg_length]
+            @size_limit = options[:size_limit]
+            @min_length = options[:min_length] || 1
+            @verbose    = options[:verbose] if @size_limit
+            @encoding   = options[:encoding] || DEFAULT_ENCODING
+
+            if @delimiter
+                @extract_method = method(:delimiter_extract)
+            elsif @indicator && @msg_length
+                @extract_method = method(:length_extract)
+            else
+                raise ArgumentError, 'no delimiter provided'
+            end
+
+            init_buffer
+        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)
+            data.force_encoding(@encoding)
+            @input << data
+
+            @extract_method.call
+        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
+            reset
+            buffer
+        end
+
+        # @return [Boolean]
+        def empty?
+            @input.empty?
+        end
+
+        # @return [Integer]
+        def bytesize
+            @input.bytesize
+        end
+
+
+        private
+
+
+        def delimiter_extract
+            # 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 || empty_string
+                entities = []
+                messages.each do |msg|
+                    res = msg.split(@indicator, -1)
+                    entities << res.last if res.length > 1
+                end
+            else
+                entities = messages
+                @input = entities.pop || empty_string
+            end
+
+            check_buffer_limits
+
+            # Check min-length is met
+            entities.select! {|msg| msg.length >= @min_length}
+
+            return entities
+        end
+
+        def length_extract
+            messages = @input.split(@indicator, -1)
+            messages.shift # discard junk data
+
+            last = messages.pop || empty_string
+
+            # Select messages of the right size then remove junk data
+            messages.select! { |msg| msg.length >= @msg_length ? true : false }
+            messages.map! { |msg| msg[0...@msg_length] }
+
+            if last.length >= @msg_length
+                messages << last[0...@msg_length]
+                @input = last[@msg_length..-1]
+            else
+                reset("#{@indicator}#{last}")
+            end
+
+            check_buffer_limits
+
+            return messages
+        end
+
+        # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+        def check_buffer_limits
+            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
+                    reset
+                end
+                raise 'input buffer exceeded limit' if @verbose
+            end
+        end
+
+        def init_buffer
+            @input = empty_string
+
+            if @delimiter.is_a?(String)
+                @delimiter = String.new(@delimiter).force_encoding(@encoding).freeze
+            end
+
+            if @indicator.is_a?(String)
+                @indicator = String.new(@indicator).force_encoding(@encoding).freeze
+            end
+        end
+
+        def reset(value = nil)
+            @input = String.new(value || '').force_encoding(@encoding)
+        end
+
+
+        protected
+
+
+        def empty_string
+            String.new.force_encoding(@encoding)
+        end
+    end
+end