mt-libuv 4.1.0

data/lib/mt-libuv/tty.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class TTY < Handle
+        include Stream
+
+
+        def initialize(reactor, fileno, readable)
+            @reactor = reactor
+
+            tty_ptr = ::MTLibuv::Ext.allocate_handle_tty
+            error = check_result(::MTLibuv::Ext.tty_init(reactor.handle, tty_ptr, fileno, readable ? 1 : 0))
+            
+            super(tty_ptr, error)
+        end
+
+        def enable_raw_mode
+            return if @closed
+            check_result ::MTLibuv::Ext.tty_set_mode(handle, 1)
+            self
+        end
+
+        def disable_raw_mode
+            return if @closed
+            check_result ::MTLibuv::Ext.tty_set_mode(handle, 0)
+            self
+        end
+
+        def reset_mode
+            ::MTLibuv::Ext.tty_reset_mode
+            self
+        end
+
+        def winsize
+            return [] if @closed
+            width = FFI::MemoryPointer.new(:int)
+            height = FFI::MemoryPointer.new(:int)
+            ::MTLibuv::Ext.tty_get_winsize(handle, width, height)
+            [width.get_int(0), height.get_int(0)]
+        end
+    end
+end

data/lib/mt-libuv/udp.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+
+module MTLibuv
+    class UDP < Handle
+        include Net
+
+
+        define_callback function: :on_allocate, params: [:pointer, :size_t, Ext::UvBuf.by_ref]
+        define_callback function: :on_recv, params: [:pointer, :ssize_t, Ext::UvBuf.by_ref, Ext::Sockaddr.by_ref, :uint]
+        define_callback function: :send_complete, params: [:pointer, :int]
+
+
+        SEND_DATA_ERROR = "data must be a String"
+        TTL_ARGUMENT_ERROR = "ttl must be an Integer"
+        MULTICAST_ARGUMENT_ERROR = "multicast_address must be a String"
+        INTERFACE_ARGUMENT_ERROR = "interface_address must be a String"
+        HANDLE_CLOSED_ERROR = "unable to send as handle closed"
+
+
+        def initialize(reactor, progress: nil, flags: nil)
+            @reactor = reactor
+            @progress = progress
+
+            udp_ptr = ::MTLibuv::Ext.allocate_handle_udp
+            error = if flags
+                check_result(::MTLibuv::Ext.udp_init_ex(reactor.handle, udp_ptr, flags))
+            else
+                check_result(::MTLibuv::Ext.udp_init(reactor.handle, udp_ptr))
+            end
+            @request_refs = {}
+
+            super(udp_ptr, error)
+        end
+
+        def bind(ip, port)
+            return if @closed
+            assert_type(String, ip, IP_ARGUMENT_ERROR)
+            assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+
+            sockaddr = create_sockaddr(ip, port)
+            error = check_result ::MTLibuv::Ext.udp_bind(handle, sockaddr, 0)
+            reject(error) if error
+
+            self
+        end
+
+        def open(fd, binding = true)
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_open(handle, fd)
+            reject(error) if error
+
+            self
+        end
+
+        def sockname
+            return [] if @closed
+            sockaddr, len = get_sockaddr_and_len
+            check_result! ::MTLibuv::Ext.udp_getsockname(handle, sockaddr, len)
+            get_ip_and_port(::MTLibuv::Ext::Sockaddr.new(sockaddr), len.get_int(0))
+        end
+
+        def join(multicast_address, interface_address)
+            return if @closed
+            assert_type(String, multicast_address, MULTICAST_ARGUMENT_ERROR)
+            assert_type(String, interface_address, INTERFACE_ARGUMENT_ERROR)
+
+            error = check_result ::MTLibuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_join_group)
+            reject(error) if error
+            self
+        end
+
+        def leave(multicast_address, interface_address)
+            return if @closed
+            assert_type(String, multicast_address, MULTICAST_ARGUMENT_ERROR)
+            assert_type(String, interface_address, INTERFACE_ARGUMENT_ERROR)
+
+            error = check_result ::MTLibuv::Ext.udp_set_membership(handle, multicast_address, interface_address, :uv_leave_group)
+            reject(error) if error
+            self
+        end
+
+        # Starts reading from the handle
+        # Renamed to match Stream
+        def start_read
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_recv_start(handle, callback(:on_allocate), callback(:on_recv))
+            reject(error) if error
+            self
+        end
+
+        # Stops reading from the handle
+        # Renamed to match Stream
+        def stop_read
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_recv_stop(handle)
+            reject(error) if error
+            self
+        end
+
+        def try_send(ip, port, data)
+            assert_type(String, ip, IP_ARGUMENT_ERROR)
+            assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+            assert_type(String, data, SEND_DATA_ERROR)
+
+            sockaddr = create_sockaddr(ip, port)
+
+            buffer1 = ::FFI::MemoryPointer.from_string(data)
+            buffer  = ::MTLibuv::Ext.buf_init(buffer1, data.respond_to?(:bytesize) ? data.bytesize : data.size)
+
+            result = ::MTLibuv::Ext.udp_try_send(
+                handle,
+                buffer,
+                1,
+                sockaddr
+            )
+            buffer1.free
+
+            error = check_result result
+            raise error if error
+            return result
+        end
+
+        def send(ip, port, data, wait: false)
+            # NOTE:: Similar to stream.rb -> write
+            deferred = @reactor.defer
+            if !@closed
+                begin
+                    assert_type(String, ip, IP_ARGUMENT_ERROR)
+                    assert_type(Integer, port, PORT_ARGUMENT_ERROR)
+                    assert_type(String, data, SEND_DATA_ERROR)
+
+                    sockaddr = create_sockaddr(ip, port)
+
+                    # Save a reference to this request
+                    req = send_req
+                    buffer1 = ::FFI::MemoryPointer.from_string(data)
+                    buffer  = ::MTLibuv::Ext.buf_init(buffer1, data.respond_to?(:bytesize) ? data.bytesize : data.size)
+                    @request_refs[req.address] = [deferred, buffer1]
+
+                    # Save the callback and return the promise
+                    error = check_result ::MTLibuv::Ext.udp_send(
+                        req,
+                        handle,
+                        buffer,
+                        1,
+                        sockaddr,
+                        callback(:send_complete, req.address)
+                    )
+                    if error
+                        @request_refs.delete req.address
+                        cleanup_callbacks req.address
+                        ::MTLibuv::Ext.free(req)
+                        buffer1.free
+                        deferred.reject(error)
+                        reject(error)       # close the handle
+                    end
+                rescue StandardError => e
+                    deferred.reject(e)
+                end
+            else
+                deferred.reject(RuntimeError.new(HANDLE_CLOSED_ERROR))
+            end
+            deferred.promise
+
+            if wait
+                return deferred.promise if wait == :promise
+                deferred.promise.value
+            end
+
+            self
+        end
+
+        def enable_multicast_reactor
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_set_multicast_reactor(handle, 1)
+            reject(error) if error
+            self
+        end
+
+        def disable_multicast_reactor
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_set_multicast_reactor(handle, 0)
+            reject(error) if error
+            self
+        end
+
+        def multicast_ttl=(ttl)
+            return if @closed
+            assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
+            error = check_result ::MTLibuv::Ext.udp_set_multicast_ttl(handle, ttl)
+            reject(error) if error
+            self
+        end
+
+        def enable_broadcast
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_set_broadcast(handle, 1)
+            reject(error) if error
+            self
+        end
+
+        def disable_broadcast
+            return if @closed
+            error = check_result ::MTLibuv::Ext.udp_set_broadcast(handle, 0)
+            reject(error) if error
+            self
+        end
+
+        def ttl=(ttl)
+            return if @closed
+            assert_type(Integer, ttl, TTL_ARGUMENT_ERROR)
+            error = check_result ::MTLibuv::Ext.udp_set_ttl(handle, Integer(ttl))
+            reject(error) if error
+            self
+        end
+
+        def progress(&callback)
+            @progress = callback
+            self
+        end
+
+
+        private
+
+
+        def send_req
+            ::MTLibuv::Ext.allocate_request_udp_send
+        end
+
+        def create_sockaddr(ip, port)
+            ips = IPAddr.new(ip)
+            if ips.ipv4?
+                addr = Ext::SockaddrIn.new
+                check_result! ::MTLibuv::Ext.ip4_addr(ip, port, addr)
+                addr
+            else
+                addr = Ext::SockaddrIn6.new
+                check_result! ::MTLibuv::Ext.ip6_addr(ip, port, addr)
+                addr
+            end
+        end
+
+
+        def on_close(pointer)
+            if @receive_buff
+                ::MTLibuv::Ext.free(@receive_buff)
+                @receive_buff = nil
+                @receive_size = nil
+            end
+
+            super(pointer)
+        end
+
+        def on_allocate(client, suggested_size, buffer)
+            if @receive_buff.nil?
+                @receive_buff = ::MTLibuv::Ext.malloc(suggested_size)
+                @receive_size = suggested_size
+            end
+            
+            buffer[:base] = @receive_buff
+            buffer[:len] = @receive_size
+        end
+
+        def on_recv(handle, nread, buf, sockaddr, flags)
+            e = check_result(nread)
+
+            if e
+                @reactor.exec { reject(e) }   # Will call close
+            elsif nread > 0
+                data = @receive_buff.read_string(nread)
+                unless sockaddr.null?
+                    ip, port = get_ip_and_port(sockaddr)
+                end
+
+                @reactor.exec do
+                    begin
+                        @progress.call data, ip, port, self
+                    rescue Exception => e
+                        @reactor.log e, 'performing UDP data received callback'
+                    end
+                end
+            else
+                ::MTLibuv::Ext.free(@receive_buff)
+                @receive_buff = nil
+                @receive_size = nil
+            end
+        end
+
+        def send_complete(req, status)
+            deferred, buffer1 = @request_refs.delete req.address
+            cleanup_callbacks req.address
+
+            ::MTLibuv::Ext.free(req)
+            buffer1.free
+
+            @reactor.exec { resolve(deferred, status) }
+        end
+    end
+end

data/lib/mt-libuv/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    VERSION = '4.1.0'
+end

data/lib/mt-libuv/work.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module MTLibuv
+    class Work < Q::DeferredPromise
+        include Resource, Listener
+
+
+        attr_reader :error
+        attr_reader :result
+
+
+        define_callback function: :on_work
+        define_callback function: :on_complete, params: [:pointer, :int]
+
+
+        # @param thread [::MTLibuv::Reactor] thread this work request will be associated
+        # @param work [Proc] callback to be called in the thread pool
+        def initialize(thread, &work)
+            super(thread, thread.defer)
+
+            @work = work
+            @complete = false
+            @pointer = ::MTLibuv::Ext.allocate_request_work
+            @error = nil    # error in callback
+
+            @instance_id = @pointer.address
+
+            error = check_result ::MTLibuv::Ext.queue_work(@reactor, @pointer, callback(:on_work), callback(:on_complete))
+            if error
+                ::MTLibuv::Ext.free(@pointer)
+                @complete = true
+                @defer.reject(error)
+            end
+        end
+
+        # Attempt to cancel the pending work. Returns true if the work has completed or was canceled.
+        #
+        # @return [true, false]
+        def cancel
+            if not @complete
+                @complete = ::MTLibuv::Ext.cancel(@pointer) >= 0
+            end
+            @complete
+        end
+
+        # Indicates is the work has completed yet or not.
+        #
+        # @return [true, false]
+        def completed?
+            return @complete
+        end
+
+
+        private
+
+
+        def on_complete(req, status)
+            @complete = true
+            ::MTLibuv::Ext.free(req)
+
+            @reactor.exec do
+                e = check_result(status)
+                if e
+                    @defer.reject(e)
+                else
+                    if @error
+                        @defer.reject(@error)
+                    else
+                        @defer.resolve(@result)
+                    end
+                end
+            end
+
+            # Clean up references
+            cleanup_callbacks @instance_id
+        end
+
+        def on_work(req)
+            begin
+                @result = @work.call
+            rescue Exception => e
+                @error = e   # Catch errors for promise resolution
+            end
+        end
+    end
+end

data/lib/mt-libuv.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'thread'
+require 'ffi'
+
+module MTLibuv
+    DefaultThread = Thread.current
+
+    require 'mt-libuv/ext/ext'     # The libuv ffi ext
+    require 'mt-libuv/error'       # List of errors (matching those in uv.h)
+    require 'mt-libuv/q'           # The promise library
+
+    # -- The classes required for a reactor instance --
+    require 'mt-libuv/mixins/assertions'  # Common code to check arguments
+    require 'mt-libuv/mixins/accessors'   # Helper methods for accessing reactor functions
+    require 'mt-libuv/mixins/resource'    # Common code to check for errors
+    require 'mt-libuv/mixins/listener'    # Common callback code
+
+    require 'mt-libuv/handle'      # Base class for most libuv functionality
+    require 'mt-libuv/prepare'     # Called at the end of a reactor cycle
+    require 'mt-libuv/async'       # Provide a threadsafe way to signal the event reactor
+    require 'mt-libuv/timer'       # High resolution timer
+    require 'mt-libuv/reactor'     # The libuv reactor or event reactor
+    require 'mt-libuv/coroutines'  # Pause program execution until a result is returned
+    require 'mt-libuv/fiber_pool'  # Fibers on jRuby and Rubinius are threads and expensive to re-create
+    # --
+
+    autoload :FsChecks, 'mt-libuv/mixins/fs_checks'   # Common code to check file system results
+    autoload :Stream,   'mt-libuv/mixins/stream'      # For all libuv streams (tcp, pipes, tty)
+    autoload :Net,      'mt-libuv/mixins/net'         # Common functions for tcp and udp
+
+    autoload :Filesystem, 'mt-libuv/filesystem'  # Async directory manipulation
+    autoload :FSEvent,    'mt-libuv/fs_event'    # Notifies of changes to files and folders as they occur
+    autoload :Signal,     'mt-libuv/signal'      # Used to handle OS signals
+    autoload :Spawn,      'mt-libuv/spawn'       # Executes a child process
+    autoload :Check,      'mt-libuv/check'       # Called before processing events on the reactor
+    autoload :File,       'mt-libuv/file'        # Async file reading and writing
+    autoload :Idle,       'mt-libuv/idle'        # Called when there are no events to process
+    autoload :Work,       'mt-libuv/work'        # Provide work to be completed on another thread (thread pool)
+    autoload :UDP,        'mt-libuv/udp'         # Communicate over UDP
+    autoload :Dns,        'mt-libuv/dns'         # Async DNS lookup
+
+    # Streams
+    autoload :Pipe, 'mt-libuv/pipe'        # Communicate over Pipes
+    autoload :TCP,  'mt-libuv/tcp'         # Communicate over TCP
+    autoload :TTY,  'mt-libuv/tty'         # Terminal output
+
+
+    # Returns the number of CPU cores on the host platform
+    # 
+    # @return [Integer, nil] representing the number of CPU cores or nil if failed
+    def self.cpu_count
+        cpu_info = FFI::MemoryPointer.new(:pointer)
+        cpu_count = FFI::MemoryPointer.new(:int)
+        if ::MTLibuv::Ext.cpu_info(cpu_info, cpu_count) >= 0
+            count = cpu_count.read_int
+            ::MTLibuv::Ext.free_cpu_info(cpu_info.read_pointer, count)
+            return count
+        else
+            return nil
+        end
+    end
+
+    # Include all the accessors at this level
+    extend Accessors
+end
+
+
+class Object
+    private
+    
+    def reactor
+        if block_given?
+            MTLibuv.reactor { |thread| yield(thread) }
+        else
+            MTLibuv.reactor
+        end
+    end
+end

data/mt-libuv.gemspec

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require File.expand_path("../lib/mt-libuv/version", __FILE__)
+
+Gem::Specification.new do |gem|
+    gem.name          = "mt-libuv"
+    gem.version       = MTLibuv::VERSION
+    gem.license       = 'MIT'
+    gem.authors       = ["Giallombardo Nathan"]
+    gem.email         = ["nathan.giallombardo@mapotempo.com"]
+    gem.homepage      = "https://github.com/Mapotempo/mt-libuv"
+    gem.summary       = "mt-libuv bindings for Ruby"
+    gem.description   = "An opinionated wrapper around mt-libuv for Ruby"
+
+    gem.extensions << "ext/Rakefile"
+
+    gem.required_ruby_version = '>= 2.0.0'
+    gem.require_paths = ["lib"]
+
+    gem.add_runtime_dependency     'ffi', '~> 1.9'
+    gem.add_runtime_dependency     'concurrent-ruby', '~> 1.0'
+    gem.add_runtime_dependency     'mt-ruby-tls', '~> 2.1'
+
+    gem.add_development_dependency 'rspec', '~> 3.5'
+    gem.add_development_dependency 'rake', '~> 11.2'
+    gem.add_development_dependency 'yard', '~> 0.9'
+
+    gem.files         = `git ls-files`.split("\n")
+    gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+    if File.exist? 'ext/libuv.dll'
+        gem.files << 'ext/libuv.dll'
+    end 
+
+    # Add the submodule to the gem
+    # relative_path = File.expand_path("../", __FILE__) + '/'
+    # `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
+
+    #     if (ENV['OS'] == 'Windows_NT') && submodule_path[0] == '/'
+    #         # Detect if cygwin path is being used by git
+    #         submodule_path = submodule_path[1..-1]
+    #         submodule_path.insert(1, ':')
+    #     end
+
+    #     # for each submodule, change working directory to that submodule
+    #     Dir.chdir(submodule_path) do
+    #         # Make the submodule path relative
+    #         submodule_path = submodule_path.gsub(/#{relative_path}/i, '')
+       
+    #         # issue git ls-files in submodule's directory
+    #         submodule_files = `git ls-files`.split($\)
+       
+    #         # prepend the submodule path to create relative file paths
+    #         submodule_files_paths = submodule_files.map do |filename|
+    #             File.join(submodule_path, filename)
+    #         end
+       
+    #         # add relative paths to gem.files
+    #         gem.files += submodule_files_paths
+    #     end
+    # end
+end

data/spec/async_spec.rb

@@ -0,0 +1,67 @@
+require 'mt-libuv'
+
+
+describe MTLibuv::Async do
+	before :each do
+		@log = []
+		@general_failure = []
+
+		@reactor = MTLibuv::Reactor.default
+		@call = @reactor.pipe
+		@timeout = @reactor.timer do
+			@reactor.stop
+			@general_failure << "test timed out"
+		end
+		@timeout.start(5000)
+
+		@reactor.all(@server, @client, @timeout).catch do |reason|
+			@general_failure << reason.inspect
+			puts "Failed with: #{reason.message}\n#{reason.backtrace.join("\n")}\n"
+		end
+
+		@reactor.notifier do |error, context|
+			begin
+				puts "Log called: #{context}\n#{error.message}\n#{error.backtrace.join("\n")}\n"
+			rescue Exception
+				puts 'error in logger'
+			end
+		end
+	end
+
+	after :each do
+		@reactor.notifier
+	end
+	
+	it "Should call the async function from the thread pool stopping the counter" do
+		@reactor.run { |reactor|
+
+			@count = 0
+
+			timer = @reactor.timer do
+				@count += 1
+			end
+			timer.start(0, 200)
+
+			callback = @reactor.async do
+				stopper = @reactor.timer do
+					timer.close
+					callback.close
+					stopper.close
+					@timeout.close
+					@reactor.stop
+				end
+				stopper.start(1000)
+				callback.close
+			end
+
+			@reactor.work {
+				callback.call
+			}.catch do |err|
+				@general_failure << err
+			end
+		}
+
+		expect(@general_failure).to eq([])
+		expect(@count < 7 && @count > 3).to eq(true)
+	end
+end