mt-libuv 4.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 55ed231748185b35f9e88cb285439d40bc75172b4c0133badf659b6a70be6969
+  data.tar.gz: 51622861571ac5be5a93e06ee86e64f5c92ed3b4bbd37236717999694c60b5cc
+SHA512:
+  metadata.gz: 3e1d126ffe76a1eb330bdb3203293088d0826270151c7e15cd6db1c09874304a2d745f5ba5909ab48268d9775a909da75f920e799a2c291229a280c1463099da
+  data.tar.gz: c30c8f7243fc969d1ae70b1e587a89f31ec49f552a085eccdf45ab031989f27731423373eb633a4e11f7def2d7ab4f2b3874ba2599d73f77c35a94a4f950494a

data/.gitignore

@@ -0,0 +1,22 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+html
+pkg
+doc
+tmp
+rerun.txt
+Gemfile.lock
+.bundle
+.idea
+*.rbc
+.yardoc
+bin
+Gemfile-custom
+ext/*
+vendor
+
+*.gem
+
+*.rdb

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "ext/libuv"]
+	path = ext/libuv
+	url = https://github.com/libuv/libuv.git
+[submodule "ext/gyp"]
+	path = ext/gyp
+	url = https://chromium.googlesource.com/external/gyp

data/.rspec

@@ -0,0 +1 @@
+--format progress

data/.travis.yml

@@ -0,0 +1,24 @@
+language: ruby
+rvm:
+  - ruby-2.3.5
+  - ruby-2.4.2
+  - ruby-head
+  - rubinius
+  - jruby-9.1.13.0
+  - jruby-head
+branches:
+  only:
+    - master
+before_install:
+  - git submodule update --init --recursive
+  - gem install ffi
+before_script:
+  - rake compile
+sudo: false
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: ruby-head
+    - rvm: rubinius
+sudo: required
+dist: trusty

data/Gemfile

@@ -0,0 +1,9 @@
+git_source(:github) do |repo_name|
+  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?('/')
+  "https://github.com/#{repo_name}.git"
+end
+
+source "https://rubygems.org"
+gemspec
+
+gem "rubysl", :platform => :rbx

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2004-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.
+
+===
+
+This license applies to all parts of uvrb (Ruby FFI bindings for libuv only)
+Libuv itself [is using Node license](https://github.com/joyent/libuv/blob/master/LICENSE)

data/README.md

@@ -0,0 +1,195 @@
+# Libuv FFI bindings for Ruby
+
+[![Build Status](https://travis-ci.org/cotag/libuv.svg?branch=master)](https://travis-ci.org/cotag/libuv)
+
+[Libuv](https://github.com/libuv/libuv) is a cross platform asynchronous IO implementation that powers NodeJS. It supports sockets, both UDP and TCP, filesystem watch, TTY, Pipes and other asynchronous primitives like timer, check, prepare and idle.
+
+The Libuv gem contains Libuv and a Ruby wrapper that implements [pipelined promises](http://en.wikipedia.org/wiki/Futures_and_promises#Promise_pipelining) for asynchronous flow control and [coroutines](http://en.wikipedia.org/wiki/Coroutine) / [futures](https://en.wikipedia.org/wiki/Futures_and_promises) for untangling evented code
+
+## Usage
+
+Libuv supports multiple reactors that can run on different threads.
+
+For convenience the thread local or default reactor can be accessed via the `reactor` method
+You can pass a block to be executed on the reactor and the reactor will run until there is nothing left to do.
+
+```ruby
+  require 'libuv'
+
+  reactor do |reactor|
+    reactor.timer {
+      puts "5 seconds passed"
+    }.start(5000)
+  end
+
+  puts "reactor stopped. No more IO to process"
+```
+
+Promises are used to simplify code flow.
+
+```ruby
+  require 'libuv'
+
+  reactor do |reactor|
+    reactor.tcp { |data, socket|
+      puts "received: #{data}"
+      socket.close
+    }
+    .connect('127.0.0.1', 3000) { |socket|
+      socket.start_read
+            .write("GET / HTTP/1.1\r\n\r\n")
+    }
+    .catch { |error|
+      puts "error: #{error}"
+    }
+    .finally {
+      puts "socket closed"
+    }
+  end
+```
+
+Continuations are used if callbacks are not defined
+
+```ruby
+  require 'libuv'
+
+  reactor do |reactor|
+    begin
+      reactor.tcp { |data, socket|
+        puts "received: #{data}"
+        socket.close
+      }
+      .connect('127.0.0.1', 3000)
+      .start_read
+      .write("GET / HTTP/1.1\r\n\r\n")
+    rescue => error
+      puts "error: #{error}"
+    end
+  end
+```
+
+Any promise can be converted into a continuation
+
+```ruby
+  require 'libuv'
+
+  reactor do |reactor|
+    # Perform work on the thread pool with promises
+    reactor.work {
+      10 * 2
+    }.then { |result|
+      puts "result using a promise #{result}"
+    }
+
+    # Use the coroutine helper to obtain the result without a callback
+    result = reactor.work {
+      10 * 3
+    }.value
+    puts "no additional callbacks here #{result}"
+  end
+```
+
+
+Check out the [yard documentation](http://rubydoc.info/gems/libuv/Libuv/Reactor)
+
+
+## Installation
+
+```shell
+  gem install libuv
+```
+
+or
+
+```shell
+  git clone https://github.com/cotag/libuv.git
+  cd libuv
+  bundle install
+  rake compile
+```
+
+### Prerequisites
+
+* The installation on BSD/Linux requires [python 2.x](http://www.python.org/getit/) to be installed and available on the PATH
+* setting the environmental variable `USE_GLOBAL_LIBUV` will prevent compiling the packaged version.
+  * if you have a compatible `libuv.(so | dylib | dll)` on the PATH already
+
+On Windows the GEM ships with a pre-compiled binary. If you would like to build yourself:
+
+- A copy of Visual Studio 2017. [Visual Studio Build Tools](https://www.visualstudio.com/downloads/#build-tools-for-visual-studio-2017) works fine.
+  - Windows 10 SDK
+  - C++/CLI Support
+  - C++ tools for CMake
+- A copy of [OpenSSL](http://slproweb.com/products/Win32OpenSSL.html) x64 - ~30MB installs
+  - ruby 2.4+ x64 with MSYS2 is preferred
+- Add the env var `set GYP_MSVS_VERSION=2017`
+- If using jRuby then [GCC](http://win-builds.org/stable/) is also required
+  - Setup the paths as described on the gcc page
+  - Add required environmental variable `set LIBRARY_PATH=X:\win-builds-64\lib;X:\win-builds-64\x86_64-w64-mingw32\lib`
+- `rake compile`
+
+
+
+## Features
+
+* TCP (with TLS support)
+* UDP
+* TTY
+* Pipes
+* Timer
+* Prepare
+* Check
+* Idle
+* Signals
+* Async callbacks
+* Async DNS Resolution
+* Filesystem Events
+* Filesystem manipulation
+* File manipulation
+* Errors (with a catch-all fallback for anything unhandled on the event reactor)
+* Work queue (thread pool)
+* Coroutines / futures (makes use of Fibers)
+
+### Server Name Indication
+
+You can host a TLS enabled server with multiple hostnames using SNI.
+
+```ruby
+server = reactor.tcp
+server.bind('0.0.0.0', 3000, **{
+    hosts: [{
+        private_key: '/blah.key',
+        cert_chain: '/blah.crt',
+        host_name: 'somehost.com',
+    },
+    {
+        private_key: '/blah2.key',
+        cert_chain: '/blah2.crt',
+        host_name: 'somehost2.com'
+    },
+    {
+        private_key: '/blah3.key',
+        cert_chain: '/blah3.crt',
+        host_name: 'somehost3.com'
+    }]
+}) do |client|
+    client.start_tls
+    client.start_read
+end
+
+# at some point later
+server.add_host(private_key: '/blah4.key', cert_chain: '/blah4.crt', host_name: 'somehost4.com')
+server.remove_host('somehost2.com')
+```
+
+You don't have to specify any hosts at binding time.
+
+
+## Protocols and 3rd party plugins
+
+* [HTTP](https://github.com/cotag/uv-rays - with SNI [server name indication] support)
+  * [Faraday plugin](https://github.com/cotag/uv-rays/blob/master/lib/faraday/adapter/libuv.rb)
+  * [HTTPI plugin](https://github.com/cotag/uv-rays/blob/master/lib/httpi/adapter/libuv.rb)
+  * [HTTP2](https://github.com/igrigorik/http-2)
+  * [SOAP](https://github.com/savonrb/savon) (using HTTPI plugin)
+* [SNMP](https://github.com/acaprojects/ruby-engine/blob/master/lib/protocols/snmp.rb)

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rspec/core/rake_task'  # testing framework
+require 'yard'                  # yard documentation
+require 'ffi'                   # loads the extension
+require 'rake/clean'            # for the :clobber rake task
+require File.expand_path('../lib/mt-libuv/ext/tasks', __FILE__)    # platform specific rake tasks used by compile
+
+
+
+# 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
+
+
+desc "Compile libuv from submodule"
+task :compile => ["ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}"]
+
+CLOBBER.include("ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}")

data/ext/README.md

@@ -0,0 +1,6 @@
+To compile a libuv.(so|dll|dylib) go to root directory of libuv project and run:
+
+```shell
+git submodule update --init
+rake compile
+```

data/ext/Rakefile

@@ -0,0 +1,28 @@
+
+require 'fileutils'
+
+if ENV.has_key?('USE_GLOBAL_LIBUV')
+    exit(0)
+else
+    require 'rubygems'
+    require 'ffi'
+    require 'rake/clean'
+    require '../lib/libuv/ext/tasks'
+
+    Dir.chdir File.expand_path("../", __FILE__)
+    Dir.chdir '..'
+
+    task :default => :libuv
+
+    if FFI::Platform.windows?
+        task :libuv do
+            FileUtils.mkdir('ext/libuv/lib')
+            FileUtils.cp 'ext/libuv.dll', 'ext/libuv/lib/libuv.dll'
+        end
+    else
+        desc "Compile libuv from submodule"
+        task :libuv => ["ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}"]
+
+        CLOBBER.include("ext/libuv/lib/libuv.#{FFI::Platform::LIBSUFFIX}")
+    end
+end

data/lib/mt-libuv/async.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Async < Handle
+
+
+        define_callback function: :on_async
+
+
+        # @param reactor [::MTLibuv::Reactor] reactor this async callback will be associated
+        def initialize(reactor)
+            @reactor = reactor
+
+            async_ptr = ::MTLibuv::Ext.allocate_handle_async
+            on_async = callback(:on_async, async_ptr.address)
+            error = check_result(::MTLibuv::Ext.async_init(reactor.handle, async_ptr, on_async))
+
+            super(async_ptr, error)
+        end
+
+        # Triggers a notify event, calling everything in the notify chain
+        def call
+            return if @closed
+            error = check_result ::MTLibuv::Ext.async_send(handle)
+            reject(error) if error
+            self
+        end
+
+        # Used to update the callback that will be triggered when async is called
+        #
+        # @param callback [Proc] the callback to be called on reactor prepare
+        def progress(&callback)
+            @callback = callback
+            self
+        end
+
+
+        private
+
+
+        def on_async(handle)
+            @reactor.exec do
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing async callback'
+                end
+            end
+        end
+    end
+end

data/lib/mt-libuv/check.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Check < Handle
+
+
+        define_callback function: :on_check
+
+
+        # @param reactor [::MTLibuv::Reactor] reactor this check will be associated
+        # @param callback [Proc] callback to be called on reactor check
+        def initialize(reactor)
+            @reactor = reactor
+
+            check_ptr = ::MTLibuv::Ext.allocate_handle_check
+            error = check_result(::MTLibuv::Ext.check_init(reactor.handle, check_ptr))
+
+            super(check_ptr, error)
+        end
+
+        # Enables the check handler.
+        def start
+            return if @closed
+            error = check_result ::MTLibuv::Ext.check_start(handle, callback(:on_check))
+            reject(error) if error
+            self
+        end
+
+        # Disables the check handler.
+        def stop
+            return if @closed
+            error = check_result ::MTLibuv::Ext.check_stop(handle)
+            reject(error) if error
+            self
+        end
+
+        # Used to update the callback that will be triggered on reactor check
+        #
+        # @param callback [Proc] the callback to be called on reactor check
+        def progress(&callback)
+            @callback = callback
+            self
+        end
+
+
+        private
+
+
+        def on_check(handle)
+            @reactor.exec do
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @reactor.log e, 'performing check callback'
+                end
+            end
+        end
+    end
+end

data/lib/mt-libuv/coroutines.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class CoroutineRejection < RuntimeError
+    attr_accessor :value
+end
+
+module MTLibuv
+    # Takes a Promise response and turns it into a co-routine
+    # for code execution without using callbacks
+    #
+    # @param *promises [::MTLibuv::Q::Promise] a number of promises that will be combined into a single promise
+    # @return [Object] Returns the result of a single promise or an array of results if provided multiple promises
+    # @raise [Exception] if the promise is rejected
+    def co(*yieldable)
+        on_reactor = MTLibuv::Reactor.current
+        raise 'must be running on a reactor thread to use coroutines' unless on_reactor
+
+        f = Fiber.current
+        wasError = false
+
+        # Convert the input into a promise on the current reactor
+        if yieldable.length == 1
+            promise = yieldable[0]
+            # Passed independently as this is often overwritten for performance
+            promise.progress &Proc.new if block_given?
+        else
+            promise = on_reactor.all(*yieldable)
+        end
+
+        # Use the promise to resume the Fiber
+        promise.then(proc { |res|
+            if MTLibuv::Reactor.current == on_reactor
+                f.resume res
+            else
+                on_reactor.schedule { f.resume(res) }
+            end
+        }, proc { |err|
+            wasError = true
+            if MTLibuv::Reactor.current == on_reactor
+                f.resume err
+            else
+                on_reactor.schedule { f.resume(err) }
+            end
+        })
+
+        # We want to prevent the reactor from stopping while we are waiting on a response
+        on_reactor.ref
+        result = Fiber.yield # Assign the result from the resume
+        on_reactor.unref
+
+        # Either return the result or raise an error
+        if wasError
+            if result.is_a?(Exception)
+                backtrace = caller
+                backtrace.shift
+                if result.respond_to?(:backtrace) && result.backtrace
+                    backtrace << '---- continuation ----'
+                    backtrace.concat(result.backtrace)
+                end
+                result.set_backtrace(backtrace)
+                raise result
+            else
+                e = case result
+                when String, Symbol
+                    CoroutineRejection.new(result.to_s)
+                else
+                    CoroutineRejection.new
+                end
+                e.value = result
+                raise e
+            end
+        end
+        result
+    end
+
+    module_function :co
+end

data/lib/mt-libuv/dns.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Dns < Q::DeferredPromise
+        include Resource, Listener, Net
+
+
+        define_callback function: :on_complete, params: [:pointer, :int, Ext::UvAddrinfo.by_ref]
+
+
+        attr_reader :results
+        attr_reader :domain
+        attr_reader :port
+        attr_reader :hint
+
+
+        HINTS = {
+            :IPv4 => ::MTLibuv::Ext::UvAddrinfo.new,
+            :IPv6 => ::MTLibuv::Ext::UvAddrinfo.new
+        }
+        HINTS[:IPv4].tap do |hint|
+            hint[:family] = FFI::Platform.windows? ? 2 : Socket::Constants::AF_INET
+            hint[:socktype] = Socket::Constants::SOCK_STREAM
+            hint[:protocol] = Socket::Constants::IPPROTO_TCP
+        end
+        HINTS[:IPv6].tap do |hint|
+            hint[:family] = FFI::Platform.windows? ? 23 : Socket::Constants::AF_INET6
+            hint[:socktype] = Socket::Constants::SOCK_STREAM
+            hint[:protocol] = Socket::Constants::IPPROTO_TCP
+        end
+
+
+        # @param reactor [::MTLibuv::Reactor] reactor this work request will be associated
+        # @param domain [String] the domain name to resolve
+        # @param port [Integer, String] the port we wish to use
+        def initialize(reactor, domain, port, hint = :IPv4, wait: true)
+            super(reactor, reactor.defer)
+
+            @domain = domain
+            @port = port
+            @hint = hint
+            @complete = false
+            @pointer = ::MTLibuv::Ext.allocate_request_getaddrinfo
+            @error = nil    # error in callback
+
+            @instance_id = @pointer.address
+            error = check_result ::MTLibuv::Ext.getaddrinfo(@reactor, @pointer, callback(:on_complete), domain, port.to_s, HINTS[hint])
+
+            if error
+                ::MTLibuv::Ext.free(@pointer)
+                @complete = true
+                @defer.reject(error)
+            end
+
+            @defer.promise.value if wait
+        end
+
+        # Indicates if the lookup has completed yet or not.
+        #
+        # @return [true, false]
+        def completed?
+            return @complete
+        end
+
+
+        private
+
+
+        def on_complete(req, status, addrinfo)
+            @complete = true
+            ::MTLibuv::Ext.free(req)
+
+            e = check_result(status)
+
+            @reactor.exec do
+                if e
+                    @defer.reject(e)
+                else
+                    begin
+                        current = addrinfo
+                        @results = []
+                        while !current.null?
+                            @results << get_ip_and_port(current[:addr])
+                            current = current[:next]
+                        end
+                        @defer.resolve(@results)
+                    rescue Exception => e
+                        @defer.reject(e)
+                    end
+                    ::MTLibuv::Ext.freeaddrinfo(addrinfo)
+                end
+            end
+
+            # Clean up references
+            cleanup_callbacks
+        end
+    end
+end