libuv 0.10.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Yjc3NDY3YzZhNTZjNGU3ZDM0NGE4NzQwN2YxYWI5NGRjM2JjYmQ1Zg==
+  data.tar.gz: !binary |-
+    MDY5ZWM3NDY2NGRhNTRjZjhjYjIyZGI2ZDNhN2RlNzJkMTk3MDAzYg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NzRiMjc5MjNlNDZjYTcwNGM1MTEwMDEzODVhYmNkMzk4OTQyZWNiNjA1OGRj
+    MTM3MTViNzM0YmQ1YzkxMzk0NWM0Mzc3YjI5MWM0Njk2OTg4NWFjNjk3YjQy
+    ZmQ4NTZkNWNhYmM5OWJmMmU2OTg1NmZmYmE1MjAwMjY4OGVkNTA=
+  data.tar.gz: !binary |-
+    ZWRlNjQwOGE5M2UxZjVmY2QzYmVlYjIxMTg2OGM1MTU0MGE1MzRlZjk4ODM3
+    Y2JiMDEzMTQ2NmU2ZTEyNjAyZmUwZGVhMDcyN2U2M2YzOTg2ZWY1NzM1YjNh
+    N2FlZGNjNTFkZmI3MzczODhkODBlYzEyOTUxOTZjMDRiMGY3NjI=

data/.gitignore

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

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/libuv"]
+	path = ext/libuv
+	url = https://github.com/joyent/libuv.git

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - rbx-20mode
+  - jruby-19mode
+  - jruby-20mode
+branches:
+  only:
+    - master
+before_install:
+  - sudo apt-get install subversion
+  - git submodule update --init --recursive
+  - echo "yes" | gem uninstall ffi -a
+before_script:
+  - rake compile

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

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,73 @@
+# Libuv FFI bindings for Ruby
+
+[![Build Status](https://travis-ci.org/cotag/libuv.png?branch=master)](https://travis-ci.org/cotag/libuv)
+
+[Libuv](https://github.com/joyent/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
+
+## Usage
+
+Create a new libuv loop or use a default one
+
+```ruby
+  require 'libuv'
+
+  loop = Libuv::Loop.default
+  # or
+  # loop = Libuv::Loop.new
+
+  loop.run do
+    timer = loop.timer do |error|
+      p error if error
+      puts "50 seconds passed"
+      timer.close
+      loop.stop
+    end
+    timer.start(50000)
+  end
+```
+
+Check out the [yard documentation](http://rubydoc.info/gems/libuv/Libuv/Loop)
+
+
+## Installation
+
+```Shell
+  gem install libuv
+```
+
+or
+
+```shell
+  git clone https://github.com/cotag/libuv.git
+  cd libuv
+  bundle install
+  rake compile
+```
+
+### Prerequisites
+
+* The installation requires __subversion__ to be installed on your system and available on the PATH
+* Windows users will require a copy of Visual Studio 2010 or later. [Visual Studio Express](http://www.microsoft.com/visualstudio/eng/products/visual-studio-express-products) works fine.
+
+or
+
+if you have a compatible `libuv.(so | dylib | dll)` on the PATH already, setting the environmental variable `USE_GLOBAL_LIBUV` will prevent compiling the packaged version.
+
+
+## What's supported
+
+* TCP
+* UDP
+* TTY
+* Pipe
+* Timer
+* Prepare
+* Check
+* Idle
+* Async
+* Filesystem Events
+* Errors
+* Work queue (thread pool)
+

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 'libuv/ext/tasks'       # 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 and tests that won't run on java (real io)
+    t.rspec_opts = "--tag ~network --tag ~real_io" 
+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.#{FFI::Platform::LIBSUFFIX}"]
+
+CLOBBER.include("ext/libuv.#{FFI::Platform::LIBSUFFIX}")

data/lib/libuv.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+require 'ffi'
+
+module Libuv
+    require 'libuv/ext/ext'     # The libuv ffi ext
+    require 'libuv/q'           # The promise library
+
+    autoload :Assertions, 'libuv/assertions'    # Common code to check arguments
+    autoload :Resource, 'libuv/resource'        # Common code to check for errors
+    autoload :Listener, 'libuv/listener'        # Common callback code
+
+    autoload :Error, 'libuv/error'              # List of errors (matching those in uv.h)
+    autoload :Net, 'libuv/net'                  # Common functions for tcp and udp
+
+    autoload :Handle, 'libuv/handle'            # Libuv handle base class
+    
+    autoload :Loop, 'libuv/loop'                # The libuv reactor or event loop
+    autoload :Timer, 'libuv/timer'              # High resolution timer
+    autoload :Check, 'libuv/check'              # Called before processing events on the loop
+    autoload :Prepare, 'libuv/prepare'          # Called at the end of a loop cycle
+    autoload :Idle, 'libuv/idle'                # Called when there are no events to process
+    autoload :Async, 'libuv/async'              # Provide a threadsafe way to signal the event loop (uses promises)
+    autoload :SimpleAsync, 'libuv/simple_async' # Same as above using a simple callback
+    autoload :Work, 'libuv/work'                # Provide work to be completed on another thread (thread pool)
+
+    # Streams
+    autoload :Stream, 'libuv/stream'
+    autoload :TCP, 'libuv/tcp'                  # Communicate over TCP
+    autoload :Pipe, 'libuv/pipe'                # Communicate over Pipes
+    autoload :TTY, 'libuv/tty'                  # Terminal output
+
+    autoload :UDP, 'libuv/udp'                  # Communicate over UDP
+    autoload :FSEvent, 'libuv/fs_event'         # Notifies of changes to files and folders as they occur
+end

data/lib/libuv/assertions.rb

@@ -0,0 +1,23 @@
+module Libuv
+    module Assertions
+        MSG_NO_PROC = 'no block given'
+
+        def assert_block(proc, msg = MSG_NO_PROC)
+            raise ArgumentError, msg, caller if proc.nil?
+        end
+
+        def assert_type(type, actual, msg = nil)
+            if not actual.kind_of?(type)
+                msg ||= "value #{actual.inspect} is not a valid #{type}"
+                raise ArgumentError, msg, caller
+            end
+        end
+
+        def assert_boolean(actual, msg = nil)
+            if not (actual.kind_of?(TrueClass) || actual.kind_of?(FalseClass))
+                msg ||= "value #{actual.inspect} is not a valid Boolean"
+                raise ArgumentError, msg, caller
+            end
+        end
+    end
+end

data/lib/libuv/async.rb

@@ -0,0 +1,33 @@
+module Libuv
+    class Async < Handle
+
+
+        def initialize(loop)
+            @loop = loop
+            async_ptr = ::Libuv::Ext.create_handle(:uv_async)
+            error = check_result(::Libuv::Ext.async_init(loop.handle, async_ptr, callback(:on_async)))
+
+            super(async_ptr, error)
+        end
+
+        def call
+            return if @closed
+            error = check_result ::Libuv::Ext.async_send(handle)
+            reject(error) if error
+        end
+
+
+        private
+
+
+        def on_async(handle, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                defer.notify(self)   # notify of a call
+            end
+        end
+    end
+end

data/lib/libuv/check.rb

@@ -0,0 +1,49 @@
+module Libuv
+    class Check < Handle
+
+
+        def initialize(loop, callback = nil, &blk)
+            @loop = loop
+            @callback = callback || blk
+
+            check_ptr = ::Libuv::Ext.create_handle(:uv_check)
+            error = check_result(::Libuv::Ext.check_init(loop.handle, check_ptr))
+
+            super(check_ptr, error)
+        end
+
+        def start
+            return if @closed
+            error = check_result ::Libuv::Ext.check_start(handle, callback(:on_check))
+            reject(error) if error
+        end
+
+        def stop
+            return if @closed
+            error = check_result ::Libuv::Ext.check_stop(handle)
+            reject(error) if error
+        end
+
+        def progress(callback = nil, &blk)
+            @callback = callback || blk
+        end
+
+
+        private
+
+
+        def on_check(handle, status)
+            e = check_result(status)
+
+            if e
+                reject(e)
+            else
+                begin
+                    @callback.call
+                rescue Exception => e
+                    @loop.log :error, :check_cb, e
+                end
+            end
+        end
+    end
+end

data/lib/libuv/error.rb

@@ -0,0 +1,70 @@
+module Libuv
+    class Error < StandardError
+        class EACCES < Error; end
+        class EADDRINUSE < Error; end
+        class EADDRNOTAVAIL < Error; end
+        class EAFNOSUPPORT < Error; end
+        class EAGAIN < Error; end
+        class EAI_ADDRFAMILY < Error; end
+        class EAI_AGAIN < Error; end
+        class EAI_BADFLAGS < Error; end
+        class EAI_CANCELED < Error; end
+        class EAI_FAIL < Error; end
+        class EAI_FAMILY < Error; end
+        class EAI_MEMORY < Error; end
+        class EAI_NODATA < Error; end
+        class EAI_NONAME < Error; end
+        class EAI_SERVICE < Error; end
+        class EAI_SOCKTYPE < Error; end
+        class EAI_SYSTEM < Error; end
+        class EALREADY < Error; end
+        class EBADF < Error; end
+        class EBUSY < Error; end
+        class ECANCELED < Error; end
+        class ECHARSET < Error; end
+        class ECONNABORTED < Error; end
+        class ECONNREFUSED < Error; end
+        class ECONNRESET < Error; end
+        class EDESTADDRREQ < Error; end
+        class EEXIST < Error; end
+        class EFAULT < Error; end
+        class EHOSTUNREACH < Error; end
+        class EINTR < Error; end
+        class EINVAL < Error; end
+        class EIO < Error; end
+        class EISCONN < Error; end
+        class EISDIR < Error; end
+        class ELOOP < Error; end
+        class EMFILE < Error; end
+        class EMSGSIZE < Error; end
+        class ENAMETOOLONG < Error; end
+        class ENETDOWN < Error; end
+        class ENETUNREACH < Error; end
+        class ENFILE < Error; end
+        class ENOBUFS < Error; end
+        class ENODEV < Error; end
+        class ENOENT < Error; end
+        class ENOMEM < Error; end
+        class ENONET < Error; end
+        class ENOSPC < Error; end
+        class ENOSYS < Error; end
+        class ENOTCONN < Error; end
+        class ENOTDIR < Error; end
+        class ENOTEMPTY < Error; end
+        class ENOTSOCK < Error; end
+        class ENOTSUP < Error; end
+        class EPERM < Error; end
+        class EPIPE < Error; end
+        class EPROTO < Error; end
+        class EPROTONOSUPPORT < Error; end
+        class EPROTOTYPE < Error; end
+        class EROFS < Error; end
+        class ESHUTDOWN < Error; end
+        class ESPIPE < Error; end
+        class ESRCH < Error; end
+        class ETIMEDOUT < Error; end
+        class EXDEV < Error; end
+        class UNKNOWN < Error; end
+        class EOF < Error; end
+    end
+end

data/lib/libuv/ext/ext.rb

@@ -0,0 +1,257 @@
+require 'forwardable'
+require 'ffi'
+
+module Libuv
+    module Ext
+        extend Forwardable
+        extend FFI::Library
+        FFI::DEBUG = 10
+
+
+        # In windows each library requires its own module
+        module LIBC
+            extend FFI::Library
+            ffi_lib(FFI::Library::LIBC).first
+
+            attach_function :malloc, [:size_t], :pointer, :blocking => true
+            attach_function :free, [:pointer], :void, :blocking => true
+        end
+        def_delegators :LIBC, :malloc, :free
+        module_function :malloc, :free
+
+
+        begin
+            # bias the library discovery to a path inside the gem first, then
+            # to the usual system paths
+            path_to_internal_libuv = File.dirname(__FILE__) + '/../../../ext'
+            LIBUV_PATHS = [
+            path_to_internal_libuv, '/usr/local/lib', '/opt/local/lib', '/usr/lib64'
+            ].map{|path| "#{path}/libuv.#{FFI::Platform::LIBSUFFIX}"}
+            libuv = ffi_lib(LIBUV_PATHS + %w{libuv}).first
+        rescue LoadError
+            warn <<-WARNING
+            Unable to load this gem. The libuv library (or DLL) could not be found.
+            If this is a Windows platform, make sure libuv.dll is on the PATH.
+            For non-Windows platforms, make sure libuv is located in this search path:
+            #{LIBUV_PATHS.inspect}
+            WARNING
+            exit 255
+        end
+
+
+        require 'libuv/ext/types'
+
+        attach_function :version_number, :uv_version, [], :uint, :blocking => true
+        attach_function :version_string, :uv_version_string, [], :string, :blocking => true
+
+        attach_function :loop_new, :uv_loop_new, [], :uv_loop_t, :blocking => true
+        attach_function :loop_delete, :uv_loop_delete, [:uv_loop_t], :void, :blocking => true
+        attach_function :default_loop, :uv_default_loop, [], :uv_loop_t, :blocking => true
+        attach_function :run, :uv_run, [:uv_loop_t, :uv_run_mode], :int, :blocking => true
+        attach_function :stop, :uv_stop, [:uv_loop_t], :void, :blocking => true
+        #attach_function :run_once, :uv_run_once, [:uv_loop_t], :int
+        attach_function :update_time, :uv_update_time, [:uv_loop_t], :void, :blocking => true
+        attach_function :now, :uv_now, [:uv_loop_t], :int64, :blocking => true
+
+        attach_function :backend_timeout, :uv_backend_timeout, [:uv_loop_t], :int, :blocking => true
+        attach_function :backend_fd, :uv_backend_fd, [:uv_loop_t], :int, :blocking => true
+
+        #attach_function :last_error, :uv_last_error, [:uv_loop_t], :int
+        attach_function :strerror, :uv_strerror, [:int], :string, :blocking => true
+        attach_function :err_name, :uv_err_name, [:int], :string, :blocking => true
+
+        attach_function :ref, :uv_ref, [:uv_handle_t], :void, :blocking => true
+        attach_function :unref, :uv_unref, [:uv_handle_t], :void, :blocking => true
+        attach_function :has_ref, :uv_has_ref, [:uv_handle_t], :int, :blocking => true
+        attach_function :is_active, :uv_is_active, [:uv_handle_t], :int, :blocking => true
+        attach_function :walk, :uv_walk, [:uv_loop_t, :uv_walk_cb, :pointer], :void, :blocking => true
+        attach_function :close, :uv_close, [:uv_handle_t, :uv_close_cb], :void, :blocking => true
+        attach_function :is_closing, :uv_is_closing, [:uv_handle_t], :int, :blocking => true
+
+        attach_function :buf_init, :uv_buf_init, [:pointer, :size_t], :uv_buf_t, :blocking => true
+        attach_function :strlcpy, :uv_strlcpy, [:string, :string, :size_t], :size_t, :blocking => true
+        attach_function :strlcat, :uv_strlcat, [:string, :string, :size_t], :size_t, :blocking => true
+
+        attach_function :listen, :uv_listen, [:uv_stream_t, :int, :uv_connection_cb], :int, :blocking => true
+        attach_function :accept, :uv_accept, [:uv_stream_t, :uv_stream_t], :int, :blocking => true
+        attach_function :read_start, :uv_read_start, [:uv_stream_t, :uv_alloc_cb, :uv_read_cb], :int, :blocking => true
+        attach_function :read_stop, :uv_read_stop, [:uv_stream_t], :int, :blocking => true
+        attach_function :read2_start, :uv_read2_start, [:uv_stream_t, :uv_alloc_cb, :uv_read2_cb], :int, :blocking => true
+        attach_function :write, :uv_write, [:uv_write_t, :uv_stream_t, :pointer, :int, :uv_write_cb], :int, :blocking => true
+        attach_function :write2, :uv_write2, [:uv_write_t, :uv_stream_t, :pointer, :int, :uv_stream_t, :uv_write_cb], :int, :blocking => true
+        attach_function :is_readable, :uv_is_readable, [:uv_stream_t], :int, :blocking => true
+        attach_function :is_writable, :uv_is_writable, [:uv_stream_t], :int, :blocking => true
+        attach_function :shutdown, :uv_shutdown, [:uv_shutdown_t, :uv_stream_t, :uv_shutdown_cb], :int, :blocking => true
+
+        attach_function :tcp_init, :uv_tcp_init, [:uv_loop_t, :uv_tcp_t], :int, :blocking => true
+        #attach_function :tcp_open, :uv_tcp_open, [:uv_tcp_t, :uv_os_sock_t], :int
+        attach_function :tcp_nodelay, :uv_tcp_nodelay, [:uv_tcp_t, :int], :int, :blocking => true
+        attach_function :tcp_keepalive, :uv_tcp_keepalive, [:uv_tcp_t, :int, :uint], :int, :blocking => true
+        attach_function :tcp_simultaneous_accepts, :uv_tcp_simultaneous_accepts, [:uv_tcp_t, :int], :int, :blocking => true
+        attach_function :tcp_bind, :uv_tcp_bind, [:uv_tcp_t, :sockaddr_in], :int, :blocking => true
+        attach_function :tcp_bind6, :uv_tcp_bind6, [:uv_tcp_t, :sockaddr_in6], :int, :blocking => true
+        attach_function :tcp_getsockname, :uv_tcp_getsockname, [:uv_tcp_t, :pointer, :pointer], :int, :blocking => true
+        attach_function :tcp_getpeername, :uv_tcp_getpeername, [:uv_tcp_t, :pointer, :pointer], :int, :blocking => true
+        attach_function :tcp_connect, :uv_tcp_connect, [:uv_connect_t, :uv_tcp_t, :sockaddr_in, :uv_connect_cb], :int, :blocking => true
+        attach_function :tcp_connect6, :uv_tcp_connect6, [:uv_connect_t, :uv_tcp_t, :sockaddr_in6, :uv_connect_cb], :int, :blocking => true
+
+        attach_function :udp_init, :uv_udp_init, [:uv_loop_t, :uv_udp_t], :int, :blocking => true
+        attach_function :udp_bind, :uv_udp_bind, [:uv_udp_t, :sockaddr_in, :uint], :int, :blocking => true
+        attach_function :udp_bind6, :uv_udp_bind6, [:uv_udp_t, :sockaddr_in6, :uint], :int, :blocking => true
+        attach_function :udp_getsockname, :uv_udp_getsockname, [:uv_udp_t, :pointer, :pointer], :int, :blocking => true
+        attach_function :udp_set_membership, :uv_udp_set_membership, [:uv_udp_t, :string, :string, :uv_membership], :int, :blocking => true
+        attach_function :udp_set_multicast_loop, :uv_udp_set_multicast_loop, [:uv_udp_t, :int], :int, :blocking => true
+        attach_function :udp_set_multicast_ttl, :uv_udp_set_multicast_ttl, [:uv_udp_t, :int], :int, :blocking => true
+        attach_function :udp_set_broadcast, :uv_udp_set_broadcast, [:uv_udp_t, :int], :int, :blocking => true
+        attach_function :udp_set_ttl, :uv_udp_set_ttl, [:uv_udp_t, :int], :int, :blocking => true
+        attach_function :udp_send, :uv_udp_send, [:uv_udp_send_t, :uv_udp_t, :pointer, :int, :sockaddr_in, :uv_udp_send_cb], :int, :blocking => true
+        attach_function :udp_send6, :uv_udp_send6, [:uv_udp_send_t, :uv_udp_t, :pointer, :int, :sockaddr_in6, :uv_udp_send_cb], :int, :blocking => true
+        attach_function :udp_recv_start, :uv_udp_recv_start, [:uv_udp_t, :uv_alloc_cb, :uv_udp_recv_cb], :int, :blocking => true
+        attach_function :udp_recv_stop, :uv_udp_recv_stop, [:uv_udp_t], :int, :blocking => true
+
+        attach_function :tty_init, :uv_tty_init, [:uv_loop_t, :uv_tty_t, :uv_file, :int], :int, :blocking => true
+        attach_function :tty_set_mode, :uv_tty_set_mode, [:uv_tty_t, :int], :int, :blocking => true
+        attach_function :tty_reset_mode, :uv_tty_reset_mode, [], :void, :blocking => true
+        attach_function :tty_get_winsize, :uv_tty_get_winsize, [:uv_tty_t, :pointer, :pointer], :int, :blocking => true
+
+        attach_function :guess_handle, :uv_guess_handle, [:uv_file], :uv_handle_type, :blocking => true
+
+        attach_function :pipe_init, :uv_pipe_init, [:uv_loop_t, :uv_pipe_t, :int], :int, :blocking => true
+        attach_function :pipe_open, :uv_pipe_open, [:uv_pipe_t, :uv_file], :void, :blocking => true
+        attach_function :pipe_bind, :uv_pipe_bind, [:uv_pipe_t, :string], :int, :blocking => true
+        attach_function :pipe_connect, :uv_pipe_connect, [:uv_connect_t, :uv_pipe_t, :string, :uv_connect_cb], :void, :blocking => true
+        attach_function :pipe_pending_instances, :uv_pipe_pending_instances, [:uv_pipe_t, :int], :void, :blocking => true
+
+        attach_function :prepare_init, :uv_prepare_init, [:uv_loop_t, :uv_prepare_t], :int, :blocking => true
+        attach_function :prepare_start, :uv_prepare_start, [:uv_prepare_t, :uv_prepare_cb], :int, :blocking => true
+        attach_function :prepare_stop, :uv_prepare_stop, [:uv_prepare_t], :int, :blocking => true
+
+        attach_function :check_init, :uv_check_init, [:uv_loop_t, :uv_check_t], :int, :blocking => true
+        attach_function :check_start, :uv_check_start, [:uv_check_t, :uv_check_cb], :int, :blocking => true
+        attach_function :check_stop, :uv_check_stop, [:uv_check_t], :int, :blocking => true
+
+        attach_function :idle_init, :uv_idle_init, [:uv_loop_t, :uv_idle_t], :int, :blocking => true
+        attach_function :idle_start, :uv_idle_start, [:uv_idle_t, :uv_idle_cb], :int, :blocking => true
+        attach_function :idle_stop, :uv_idle_stop, [:uv_idle_t], :int, :blocking => true
+
+        attach_function :async_init, :uv_async_init, [:uv_loop_t, :uv_async_t, :uv_async_cb], :int, :blocking => true
+        attach_function :async_send, :uv_async_send, [:uv_async_t], :int, :blocking => true
+
+        attach_function :timer_init, :uv_timer_init, [:uv_loop_t, :uv_timer_t], :int, :blocking => true
+        attach_function :timer_start, :uv_timer_start, [:uv_timer_t, :uv_timer_cb, :int64_t, :int64_t], :int, :blocking => true
+        attach_function :timer_stop, :uv_timer_stop, [:uv_timer_t], :int, :blocking => true
+        attach_function :timer_again, :uv_timer_again, [:uv_timer_t], :int, :blocking => true
+        attach_function :timer_set_repeat, :uv_timer_set_repeat, [:uv_timer_t, :int64_t], :void, :blocking => true
+        attach_function :timer_get_repeat, :uv_timer_get_repeat, [:uv_timer_t], :int64_t, :blocking => true
+
+        #attach_function :ares_init_options, :uv_ares_init_options, [:uv_loop_t, :ares_channel, :ares_options, :int], :int
+        #attach_function :ares_destroy, :uv_ares_destroy, [:uv_loop_t, :ares_channel], :void
+
+        attach_function :getaddrinfo, :uv_getaddrinfo, [:uv_loop_t, :uv_getaddrinfo_t, :uv_getaddrinfo_cb, :string, :string, :addrinfo], :int, :blocking => true
+        attach_function :freeaddrinfo, :uv_freeaddrinfo, [:addrinfo], :void, :blocking => true
+
+        attach_function :spawn, :uv_spawn, [:uv_loop_t, :uv_process_t, :uv_options_t], :int, :blocking => true
+        attach_function :process_kill, :uv_process_kill, [:uv_process_t, :int], :int, :blocking => true
+        attach_function :kill, :uv_kill, [:int, :int], :int, :blocking => true
+        attach_function :queue_work, :uv_queue_work, [:uv_loop_t, :uv_work_t, :uv_work_cb, :uv_after_work_cb], :int, :blocking => true
+        attach_function :cancel, :uv_cancel, [:pointer], :int, :blocking => true
+        attach_function :setup_args, :uv_setup_args, [:int, :varargs], :pointer, :blocking => true
+        attach_function :get_process_title, :uv_get_process_title, [:pointer, :size_t], :int, :blocking => true
+        attach_function :set_process_title, :uv_set_process_title, [:string], :int, :blocking => true
+        attach_function :resident_set_memory, :uv_resident_set_memory, [:size_t], :int, :blocking => true
+
+        attach_function :uptime, :uv_uptime, [:pointer], :int, :blocking => true
+        attach_function :cpu_info, :uv_cpu_info, [:uv_cpu_info_t, :pointer], :int, :blocking => true
+        attach_function :loadavg, :uv_loadavg, [:pointer], :void, :blocking => true
+        attach_function :free_cpu_info, :uv_free_cpu_info, [:uv_cpu_info_t, :int], :void, :blocking => true
+        attach_function :interface_addresses, :uv_interface_addresses, [:uv_interface_address_t, :pointer], :int, :blocking => true
+        attach_function :free_interface_addresses, :uv_free_interface_addresses, [:uv_interface_address_t, :int], :void, :blocking => true
+
+        #attach_function :fs_req_result, :uv_fs_req_result, [:uv_fs_t], :ssize_t
+        #attach_function :fs_req_stat, :uv_fs_req_stat, [:uv_fs_t], :uv_fs_stat_t
+        #attach_function :fs_req_pointer, :uv_fs_req_pointer, [:uv_fs_t], :pointer
+
+        attach_function :fs_req_cleanup, :uv_fs_req_cleanup, [:uv_fs_t], :void, :blocking => true
+        attach_function :fs_close, :uv_fs_close, [:uv_loop_t, :uv_fs_t, :uv_file, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_open, :uv_fs_open, [:uv_loop_t, :uv_fs_t, :string, :int, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_read, :uv_fs_read, [:uv_loop_t, :uv_fs_t, :uv_file, :string, :size_t, :off_t, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_unlink, :uv_fs_unlink, [:uv_loop_t, :uv_fs_t, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_write, :uv_fs_write, [:uv_loop_t, :uv_fs_t, :uv_file, :string, :size_t, :off_t, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_mkdir, :uv_fs_mkdir, [:uv_loop_t, :uv_fs_t, :string, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_rmdir, :uv_fs_rmdir, [:uv_loop_t, :uv_fs_t, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_readdir, :uv_fs_readdir, [:uv_loop_t, :uv_fs_t, :string, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_stat, :uv_fs_stat, [:uv_loop_t, :uv_fs_t, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_fstat, :uv_fs_fstat, [:uv_loop_t, :uv_fs_t, :uv_file, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_rename, :uv_fs_rename, [:uv_loop_t, :uv_fs_t, :string, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_fsync, :uv_fs_fsync, [:uv_loop_t, :uv_fs_t, :uv_file, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_fdatasync, :uv_fs_fdatasync, [:uv_loop_t, :uv_fs_t, :uv_file, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_ftruncate, :uv_fs_ftruncate, [:uv_loop_t, :uv_fs_t, :uv_file, :off_t, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_sendfile, :uv_fs_sendfile, [:uv_loop_t, :uv_fs_t, :uv_file, :uv_file, :off_t, :size_t, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_chmod, :uv_fs_chmod, [:uv_loop_t, :uv_fs_t, :string, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_utime, :uv_fs_utime, [:uv_loop_t, :uv_fs_t, :string, :double, :double, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_futime, :uv_fs_futime, [:uv_loop_t, :uv_fs_t, :uv_file, :double, :double, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_lstat, :uv_fs_lstat, [:uv_loop_t, :uv_fs_t, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_link, :uv_fs_link, [:uv_loop_t, :uv_fs_t, :string, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_symlink, :uv_fs_symlink, [:uv_loop_t, :uv_fs_t, :string, :string, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_readlink, :uv_fs_readlink, [:uv_loop_t, :uv_fs_t, :string, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_fchmod, :uv_fs_fchmod, [:uv_loop_t, :uv_fs_t, :uv_file, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_chown, :uv_fs_chown, [:uv_loop_t, :uv_fs_t, :string, :int, :int, :uv_fs_cb], :int, :blocking => true
+        attach_function :fs_fchown, :uv_fs_fchown, [:uv_loop_t, :uv_fs_t, :uv_file, :int, :int, :uv_fs_cb], :int, :blocking => true
+
+        attach_function :fs_event_init, :uv_fs_event_init, [:uv_loop_t, :uv_fs_event_t, :string, :uv_fs_event_cb, :int], :int, :blocking => true
+
+        attach_function :ip4_addr, :uv_ip4_addr, [:string, :int], :sockaddr_in, :blocking => true
+        attach_function :ip6_addr, :uv_ip6_addr, [:string, :int], :sockaddr_in6, :blocking => true
+        attach_function :ip4_name, :uv_ip4_name, [SockaddrIn.by_ref, :pointer, :size_t], :int, :blocking => true
+        attach_function :ip6_name, :uv_ip6_name, [SockaddrIn6.by_ref, :pointer, :size_t], :int, :blocking => true
+        #TODO:: attach_function :inet_ntop, :uv_inet_ntop, [:int, :pointer, ]
+        #TODO:: attach_function :uv_inet_pton
+
+        attach_function :exepath, :uv_exepath, [:pointer, :size_t], :int, :blocking => true
+        attach_function :cwd, :uv_cwd, [:pointer, :size_t], :int, :blocking => true
+        attach_function :chdir, :uv_chdir, [:string], :int, :blocking => true
+        attach_function :get_free_memory, :uv_get_free_memory, [], :uint64, :blocking => true
+        attach_function :get_total_memory, :uv_get_total_memory, [], :uint64, :blocking => true
+        attach_function :hrtime, :uv_hrtime, [], :uint64, :blocking => true
+        attach_function :disable_stdio_inheritance, :uv_disable_stdio_inheritance, [], :void, :blocking => true
+        attach_function :dlopen, :uv_dlopen, [:string, :uv_lib_t], :int, :blocking => true
+        attach_function :dlclose, :uv_dlclose, [:uv_lib_t], :int, :blocking => true
+        attach_function :dlsym, :uv_dlsym, [:uv_lib_t, :string, :pointer], :int, :blocking => true
+        #attach_function :dlerror, :uv_dlerror, [:uv_lib_t], :string
+        #attach_function :dlerror_free, :uv_dlerror_free, [:uv_lib_t, :string], :void
+
+        attach_function :mutex_init, :uv_mutex_init, [:uv_mutex_t], :int, :blocking => true
+        attach_function :mutex_destroy, :uv_mutex_destroy, [:uv_mutex_t], :void, :blocking => true
+        attach_function :mutex_lock, :uv_mutex_lock, [:uv_mutex_t], :void, :blocking => true
+        attach_function :mutex_trylock, :uv_mutex_trylock, [:uv_mutex_t], :int, :blocking => true
+        attach_function :mutex_unlock, :uv_mutex_unlock, [:uv_mutex_t], :void, :blocking => true
+
+        attach_function :rwlock_init, :uv_rwlock_init, [:uv_rwlock_t], :int, :blocking => true
+        attach_function :rwlock_destroy, :uv_rwlock_destroy, [:uv_rwlock_t], :void, :blocking => true
+        attach_function :rwlock_rdlock, :uv_rwlock_rdlock, [:uv_rwlock_t], :void, :blocking => true
+        attach_function :rwlock_tryrdlock, :uv_rwlock_tryrdlock, [:uv_rwlock_t], :int, :blocking => true
+        attach_function :rwlock_rdunlock, :uv_rwlock_rdunlock, [:uv_rwlock_t], :void, :blocking => true
+        attach_function :rwlock_wrlock, :uv_rwlock_wrlock, [:uv_rwlock_t], :void, :blocking => true
+        attach_function :rwlock_trywrlock, :uv_rwlock_trywrlock, [:uv_rwlock_t], :int, :blocking => true
+        attach_function :rwlock_wrunlock, :uv_rwlock_wrunlock, [:uv_rwlock_t], :void, :blocking => true
+
+        attach_function :once, :uv_once, [:uv_once_t, :uv_cb], :void, :blocking => true
+        attach_function :thread_create, :uv_thread_create, [:uv_thread_t, :uv_cb], :int, :blocking => true
+        attach_function :thread_join, :uv_thread_join, [:uv_thread_t], :int, :blocking => true
+
+        attach_function :handle_size, :uv_handle_size, [:uv_handle_type], :size_t, :blocking => true
+        attach_function :req_size, :uv_req_size, [:uv_req_type], :size_t, :blocking => true
+
+        # This function is attached differently in windows - see ./types/windows.rb
+        attach_function :ntohs, [:ushort], :ushort, :blocking => true unless FFI::Platform.windows?
+
+
+        def self.create_handle(type)
+            LIBC.malloc(Ext.handle_size(type))
+        end
+
+        def self.create_request(type)
+            LIBC.malloc(Ext.req_size(type))
+        end
+    end
+end