noderb 0.0.4 → 0.0.6

data/ext/noderb_extension/noderb_fs.c

@@ -0,0 +1,277 @@
+#include <noderb_common.h>
+
+#include <noderb_fs.h>
+#include <noderb_tools.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+typedef struct {
+    long target;
+    char* buffer;
+} nodeRb_file_handle;
+
+void nodeRb_fs_operation_callback(uv_fs_t* handle){
+    nodeRb_file_handle* data = (nodeRb_file_handle*) handle->data;
+    VALUE target = nodeRb_get_class_from_id(data->target);
+    if(handle->result == -1){
+        rb_funcall(target, rb_intern("call"), 1, Qnil);
+    }else{
+        switch(handle->fs_type) {
+            case UV_FS_UNLINK:
+            case UV_FS_MKDIR:
+            case UV_FS_RMDIR:
+            case UV_FS_RENAME:
+            case UV_FS_CHMOD:
+            case UV_FS_UTIME:
+            case UV_FS_LINK:
+            case UV_FS_SYMLINK:
+            case UV_FS_CHOWN:
+                rb_funcall(target, rb_intern("call"), 1, Qtrue);
+                break;
+            case UV_FS_READLINK:
+                rb_funcall(target, rb_intern("call"), 1, rb_str_new((char*) handle->ptr, handle->result));
+                break;
+            case UV_FS_READDIR:
+                rb_funcall(target, rb_intern("call"), 1, rb_str_new((char*) handle->ptr, handle->result));
+                break;
+            case UV_FS_LSTAT:
+            case UV_FS_STAT:
+                {
+                    NODERB_STAT_STRUCT* stats = (NODERB_STAT_STRUCT*) handle->ptr;
+                    VALUE values = rb_funcall(rb_path2class("NodeRb::Stat"), rb_intern("new"), 0, 0);
+
+                    rb_iv_set(values, "@device", LONG2NUM(stats->st_dev));
+                    rb_iv_set(values, "@inode", LONG2NUM(stats->st_ino));
+                    rb_iv_set(values, "@rdevice", LONG2NUM(stats->st_rdev));
+
+                    rb_iv_set(values, "@uid", LONG2NUM(stats->st_uid));
+                    rb_iv_set(values, "@gid", LONG2NUM(stats->st_gid));
+                    rb_iv_set(values, "@size", LONG2NUM(stats->st_size));
+                    rb_iv_set(values, "@links", LONG2NUM(stats->st_nlink));
+                    rb_iv_set(values, "@mode", LONG2NUM(stats->st_mode));
+                    rb_iv_set(values, "@block_size", LONG2NUM(stats->st_blksize));
+                    rb_iv_set(values, "@blocks", LONG2NUM(stats->st_blocks));
+
+                    rb_iv_set(values, "@accessed", LONG2NUM(stats->st_atime));
+                    rb_iv_set(values, "@modified", LONG2NUM(stats->st_mtime));
+                    rb_iv_set(values, "@changed", LONG2NUM(stats->st_ctime));
+
+                    rb_funcall(target, rb_intern("call"), 1, values);
+                }
+                break;
+        }
+    }
+    nodeRb_unregister_instance(target);
+    free(handle->data);
+    uv_fs_req_cleanup(handle);
+}
+
+VALUE nodeRb_fs_operation(VALUE self, VALUE roperation, VALUE path, VALUE params, VALUE callback){
+    uv_fs_t* handle = malloc(sizeof(uv_fs_t));
+    nodeRb_file_handle* data = malloc(sizeof(nodeRb_file_handle));
+    nodeRb_register_instance(callback);
+    data->target = rb_num2long(rb_obj_id(callback));
+    long operation = rb_num2long(roperation);
+    switch(operation){
+        case 0:
+            uv_fs_unlink(uv_default_loop(), handle, rb_string_value_cstr(&path), nodeRb_fs_operation_callback);
+            break;
+        case 1:
+            uv_fs_mkdir(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(params), nodeRb_fs_operation_callback);
+            break;
+        case 2:
+            uv_fs_rmdir(uv_default_loop(), handle, rb_string_value_cstr(&path), nodeRb_fs_operation_callback);
+            break;
+        case 3:
+            uv_fs_readdir(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(params), nodeRb_fs_operation_callback);
+            break;
+        case 4:
+            uv_fs_stat(uv_default_loop(), handle, rb_string_value_cstr(&path), nodeRb_fs_operation_callback);
+            break;
+        case 5:
+            uv_fs_rename(uv_default_loop(), handle, rb_string_value_cstr(&path), rb_string_value_cstr(&params), nodeRb_fs_operation_callback);
+            break;
+        case 6:
+            uv_fs_chmod(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(params), nodeRb_fs_operation_callback);
+            break;
+        case 7:
+            uv_fs_utime(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(rb_ary_entry(params, 0)), (int) rb_num2long(rb_ary_entry(params, 1)), nodeRb_fs_operation_callback);
+            break;
+        case 8:
+            uv_fs_lstat(uv_default_loop(), handle, rb_string_value_cstr(&path), nodeRb_fs_operation_callback);
+            break;
+        case 9:
+            uv_fs_link(uv_default_loop(), handle, rb_string_value_cstr(&path), rb_string_value_cstr(&params), nodeRb_fs_operation_callback);
+            break;
+        case 10:
+            {
+                VALUE new_path = rb_ary_entry(params, 0);
+                // (int) rb_num2long(rb_ary_entry(params, 1))
+                uv_fs_symlink(uv_default_loop(), handle, rb_string_value_cstr(&path), rb_string_value_cstr(&new_path), nodeRb_fs_operation_callback);
+            }
+            break;
+        case 11:
+            uv_fs_readlink(uv_default_loop(), handle, rb_string_value_cstr(&path), nodeRb_fs_operation_callback);
+            break;
+        case 12:
+            uv_fs_chown(uv_default_loop(), handle, rb_string_value_cstr(&path), (int) rb_num2long(rb_ary_entry(params, 0)), (int) rb_num2long(rb_ary_entry(params, 1)), nodeRb_fs_operation_callback);
+            break;
+    }
+    handle->data = data;
+}
+
+void nodeRb_fs_file_operation_callback(uv_fs_t* handle){
+    nodeRb_file_handle* data = (nodeRb_file_handle*) handle->data;
+    VALUE target = nodeRb_get_class_from_id(data->target);
+    if(handle->result == -1){
+        rb_funcall(target, rb_intern("on_error"), 0, 0);
+    }else{
+        switch(handle->fs_type) {
+            case UV_FS_SENDFILE:
+                rb_funcall(target, rb_intern("on_sendfile"), 0, 0);
+                break;
+            case UV_FS_FTRUNCATE:
+                rb_funcall(target, rb_intern("on_truncate"), 0, 0);
+                break;
+            case UV_FS_FUTIME:
+                rb_funcall(target, rb_intern("on_utime"), 0, 0);
+                break;
+            case UV_FS_FCHMOD:
+                rb_funcall(target, rb_intern("on_chmod"), 0, 0);
+                break;
+            case UV_FS_FSYNC:
+                rb_funcall(target, rb_intern("on_sync"), 0, 0);
+                break;
+            case UV_FS_FDATASYNC:
+                rb_funcall(target, rb_intern("on_datasync"), 0, 0);
+                break;
+            case UV_FS_FCHOWN:
+                rb_funcall(target, rb_intern("on_chown"), 0, 0);
+                break;
+            case UV_FS_WRITE:
+                rb_funcall(target, rb_intern("on_write"), 0, 0);
+                break;
+            case UV_FS_FSTAT:
+                {
+                    NODERB_STAT_STRUCT* stats = (NODERB_STAT_STRUCT*) handle->ptr;
+                    VALUE values = rb_funcall(rb_path2class("NodeRb::Stat"), rb_intern("new"), 0, 0);
+
+                    rb_iv_set(values, "@device", LONG2NUM(stats->st_dev));
+                    rb_iv_set(values, "@inode", LONG2NUM(stats->st_ino));
+                    rb_iv_set(values, "@rdevice", LONG2NUM(stats->st_rdev));
+
+                    rb_iv_set(values, "@uid", LONG2NUM(stats->st_uid));
+                    rb_iv_set(values, "@gid", LONG2NUM(stats->st_gid));
+                    rb_iv_set(values, "@size", LONG2NUM(stats->st_size));
+                    rb_iv_set(values, "@links", LONG2NUM(stats->st_nlink));
+                    rb_iv_set(values, "@mode", LONG2NUM(stats->st_mode));
+                    rb_iv_set(values, "@block_size", LONG2NUM(stats->st_blksize));
+                    rb_iv_set(values, "@blocks", LONG2NUM(stats->st_blocks));
+
+                    rb_iv_set(values, "@accessed", LONG2NUM(stats->st_atime));
+                    rb_iv_set(values, "@modified", LONG2NUM(stats->st_mtime));
+                    rb_iv_set(values, "@changed", LONG2NUM(stats->st_ctime));
+
+                    rb_funcall(target, rb_intern("on_stat"), 1, values);
+                }
+                break;
+            case UV_FS_OPEN:
+                {
+                    uv_file fd = (uv_file) handle->result;
+                    rb_iv_set(target, "@_handle", INT2NUM(fd));
+                    rb_funcall(target, rb_intern("on_open"), 0, 0);
+                }
+                break;
+            case UV_FS_READ:
+                {
+                    int size = (int) handle->result;
+                    char* buf = data->buffer;
+                    rb_funcall(target, rb_intern("on_read"), 1, rb_str_new(buf, size));
+                    free(buf);
+                }
+                break;
+            case UV_FS_CLOSE:
+                rb_funcall(target, rb_intern("on_close"), 0, 0);
+                nodeRb_unregister_instance(target);
+                rb_iv_set(target, "@_handle", Qnil);
+                break;
+        }
+    }
+    free(handle->data);
+    uv_fs_req_cleanup(handle);
+}
+
+VALUE nodeRb_fs_file_operation(VALUE self, VALUE roperation, VALUE params){
+    long operation = rb_num2long(roperation);
+    uv_file fd;
+    if(operation > 0){
+        fd = (int) rb_num2long(rb_iv_get(self, "@_handle"));
+    }
+    // Allocate memory
+    uv_fs_t* handle = malloc(sizeof(uv_fs_t));
+    nodeRb_file_handle* data = malloc(sizeof(nodeRb_file_handle));
+    // Save Ruby data
+    data->target = rb_num2long(rb_obj_id(self));
+    // Open file
+    switch(operation){
+        case 0:
+            {
+                int mode = (int) rb_num2long(rb_ary_entry(params,1));
+                switch(mode){
+                    case 0:
+                        mode = O_RDWR | O_CREAT;
+                        break;
+                    case 1:
+                        mode = O_RDONLY;
+                        break;
+                    case 2:
+                        mode = O_WRONLY | O_CREAT;
+                        break;
+                }
+                VALUE file = rb_ary_entry(params,0);
+                uv_fs_open(uv_default_loop(), handle, rb_string_value_cstr(&file), mode, (int) rb_num2long(rb_ary_entry(params,2)), nodeRb_fs_file_operation_callback);
+            }
+            break;
+        case 1:
+            {
+                long size = rb_num2long(rb_ary_entry(params,0));
+                long offset = rb_num2long(rb_ary_entry(params,1));
+                char* buf = (char*) malloc(size);
+                data->buffer = buf;
+                uv_fs_read(uv_default_loop(), handle, fd, buf, size, offset, nodeRb_fs_file_operation_callback);
+            }
+            break;
+        case 2:
+            uv_fs_write(uv_default_loop(), handle, fd, rb_string_value_ptr(&params), RSTRING_LEN(params), 0, nodeRb_fs_file_operation_callback);
+            break;
+        case 3:
+            uv_fs_fstat(uv_default_loop(), handle, fd, nodeRb_fs_file_operation_callback);
+            break;
+        case 4:
+            uv_fs_fsync(uv_default_loop(), handle, fd, nodeRb_fs_file_operation_callback);
+            break;
+        case 5:
+            uv_fs_fdatasync(uv_default_loop(), handle, fd, nodeRb_fs_file_operation_callback);
+            break;
+        case 6:
+            uv_fs_ftruncate(uv_default_loop(), handle, fd, (int) rb_num2long(params), nodeRb_fs_file_operation_callback);
+            break;
+        case 7:
+            uv_fs_sendfile(uv_default_loop(), handle, fd, (int) rb_num2long(rb_ary_entry(params,0)), (int) rb_num2long(rb_ary_entry(params,1)), (int) rb_num2long(rb_ary_entry(params,2)), nodeRb_fs_file_operation_callback);
+            break;
+        case 8:
+            uv_fs_futime(uv_default_loop(), handle, fd, (int) rb_num2long(rb_ary_entry(params,0)), (int) rb_num2long(rb_ary_entry(params,1)), nodeRb_fs_file_operation_callback);
+            break;
+        case 9:
+            uv_fs_fchmod(uv_default_loop(), handle, fd, (int) rb_num2long(params), nodeRb_fs_file_operation_callback);
+            break;
+        case 10:
+            uv_fs_fchown(uv_default_loop(), handle, fd, (int) rb_num2long(rb_ary_entry(params,0)), (int) rb_num2long(rb_ary_entry(params,1)), nodeRb_fs_file_operation_callback);
+            break;
+        case 11:
+            uv_fs_close(uv_default_loop(), handle, fd, nodeRb_fs_file_operation_callback);
+            break;
+    }
+    handle->data = data;
+}

data/ext/noderb_extension/noderb_fs.h

@@ -0,0 +1,27 @@
+#ifndef NODERB_FS_H
+#define	NODERB_FS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+VALUE nodeRb_fs_open(VALUE self, VALUE file, VALUE mode, VALUE rgh);
+VALUE nodeRb_fs_read(VALUE self, VALUE size, VALUE fromToRead);
+VALUE nodeRb_fs_write(VALUE self, VALUE data);
+VALUE nodeRb_fs_close(VALUE self);
+
+VALUE nodeRb_fs_operation(VALUE self, VALUE roperation, VALUE path, VALUE params, VALUE callback);
+VALUE nodeRb_fs_file_operation(VALUE self, VALUE roperation, VALUE params);
+
+// ToDo: Taken from NodeJs
+
+#define NODERB_STAT        stat
+#define NODERB_FSTAT       fstat
+#define NODERB_STAT_STRUCT struct stat
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* NODERB_FS_H */
+

data/ext/noderb_extension/noderb_process.c

@@ -30,7 +30,7 @@ VALUE nodeRb_process_write(VALUE self, VALUE data) {
     uv_write_t write_req;
     uv_buf_t buf;
     // Get data to write from Ruby
-    char* buffer = rb_string_value_cstr(&data);
+    char* buffer = rb_string_value_ptr(&data);
     // Get process handle
     nodeRb_process_handle* process_handle = (nodeRb_process_handle*) handle->data;
     // Write data to stream
@@ -90,12 +90,12 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     nodeRb_register_instance(clazz);
     // stdin
     uv_pipe_t* stdin = malloc(sizeof(uv_pipe_t));
-    uv_pipe_init(stdin);
+    uv_pipe_init(uv_default_loop(), stdin);
     options.stdin_stream = stdin;
     process_handle->stdin = stdin;
     // stdout
     uv_pipe_t* stdout = malloc(sizeof(uv_pipe_t));
-    uv_pipe_init(stdout);
+    uv_pipe_init(uv_default_loop(), stdout);
     options.stdout_stream = stdout;
     nodeRb_process_read_handle* stdout_handle = malloc(sizeof(nodeRb_process_read_handle));
     stdout_handle->target = process_handle->target;
@@ -104,7 +104,7 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     process_handle->stdout = stdout;
     // stderr
     uv_pipe_t* stderr = malloc(sizeof(uv_pipe_t));
-    uv_pipe_init(stderr);
+    uv_pipe_init(uv_default_loop(), stderr);
     options.stderr_stream = stderr;
     nodeRb_process_read_handle* stderr_handle = malloc(sizeof(nodeRb_process_read_handle));
     stderr_handle->target = process_handle->target;
@@ -117,7 +117,7 @@ VALUE nodeRb_startProcess(VALUE self, VALUE executable, VALUE arguments, VALUE e
     // Save reference into Ruby object
     rb_iv_set(clazz, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, handle));
     // spawn process
-    uv_spawn(handle, options);
+    uv_spawn(uv_default_loop(), handle, options);
     // Listen to stdout/err
     uv_read_start((uv_stream_t*) stdout, nodeRb_read_alloc, nodeRb_read);
     uv_read_start((uv_stream_t*) stderr, nodeRb_read_alloc, nodeRb_read);

data/ext/noderb_extension/noderb_tcp.c

@@ -21,6 +21,7 @@ void nodeRb_tcp_on_close(uv_handle_t* client) {
     // Allow GC of handler instance
     nodeRb_unregister_instance(object);
     rb_iv_set(object, "@_handle", Qnil);
+    rb_iv_set(object, "@_proxy_target", Qnil);
     // Clean up some memory
     free(client_data);
     free(client);
@@ -48,7 +49,7 @@ VALUE nodeRb_tcp_send_data(VALUE self, VALUE data) {
     uv_stream_t *handle;
     Data_Get_Struct(rb_iv_get(self, "@_handle"), uv_stream_t, handle);
     // Request write to stream
-    nodeRb_write(handle, rb_string_value_cstr(&data), RSTRING_LEN(data));
+    nodeRb_write(handle, rb_string_value_ptr(&data), RSTRING_LEN(data));
 }
 
 /*
@@ -59,6 +60,7 @@ void nodeRb_tcp_on_client_connect(uv_connect_t* client, int status) {
     nodeRb_client *client_data = client->handle->data;
     VALUE obj = nodeRb_get_class_from_id(client_data->target);
     rb_iv_set(obj, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client->handle));
+    rb_iv_set(obj, "@_proxy_target", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client->handle));
     rb_funcall(obj, rb_intern("on_connect"), 0, 0);
     uv_read_start((uv_stream_t*) client->handle, nodeRb_read_alloc, nodeRb_read);
 }
@@ -66,7 +68,7 @@ void nodeRb_tcp_on_client_connect(uv_connect_t* client, int status) {
 VALUE nodeRb_tcp_startClient(VALUE self, VALUE address, VALUE port, VALUE clazz) {
     // Allocate memory for connection
     uv_tcp_t *handle = malloc(sizeof (uv_tcp_t));
-    uv_tcp_init(handle);
+    uv_tcp_init(uv_default_loop(), handle);
     uv_connect_t *connect = malloc(sizeof (uv_connect_t));
     // Translate IP address
     struct sockaddr_in socket = uv_ip4_addr(rb_string_value_cstr(&address), (int) rb_num2long(port));
@@ -89,7 +91,7 @@ void nodeRb_tcp_on_server_connect(uv_stream_t* server, int status) {
     nodeRb_client *client_data = malloc(sizeof (nodeRb_client));
     // Allocate for client
     uv_stream_t *client = malloc(sizeof (uv_tcp_t));
-    uv_tcp_init((uv_tcp_t*) client);
+    uv_tcp_init(uv_default_loop(), (uv_tcp_t*) client);
     // Accept connection
     int r = uv_accept(server, client);
     if (nodeRb_handle_error(r)) return;
@@ -98,21 +100,23 @@ void nodeRb_tcp_on_server_connect(uv_stream_t* server, int status) {
     VALUE obj = rb_funcall(clazz, rb_intern("new"), 0, 0);
     // Be safe from GC
     nodeRb_register_instance(obj);
-    // Call callback
-    rb_funcall(obj, rb_intern("on_connect"), 0, 0);
     // Save client data with this connection handler instance
     rb_iv_set(obj, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client));
+    rb_iv_set(obj, "@_proxy_target", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, client));
     // Get object id of handler instance
     client_data->target = rb_num2long(rb_obj_id(obj));
     client_data->target_callback = (char*) "on_data";
     client->data = client_data;
+    // Call callback
+    rb_funcall(obj, rb_intern("on_connect"), 0, 0);
+    // Listen for incoming data
     uv_read_start(client, nodeRb_read_alloc, nodeRb_read);
 }
 
 VALUE nodeRb_tcp_startServer(VALUE self, VALUE address, VALUE port, VALUE clazz) {
     // Allocate for server
     uv_tcp_t *server = malloc(sizeof (uv_tcp_t));
-    uv_tcp_init(server);
+    uv_tcp_init(uv_default_loop(), server);
     // Translate IP address
     struct sockaddr_in socket = uv_ip4_addr(rb_string_value_cstr(&address), (int) rb_num2long(port));
     // Bind on socket

data/ext/noderb_extension/noderb_timers.c

@@ -49,7 +49,7 @@ VALUE nodeRb_timers_once(VALUE self, VALUE timeout, VALUE repeat, VALUE handler)
     }
     data->target = rb_num2long(rb_obj_id(handler));
     // Initialize
-    uv_timer_init(handle);
+    uv_timer_init1(uv_default_loop(), handle);
     handle->data = data;
     // Save handle
     rb_iv_set(handler, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, handle));

data/ext/noderb_extension/noderb_tools.c

@@ -7,19 +7,25 @@
 */
 
 // Allocates memory exactly as libuv suggests, this might be one area of optimization
-uv_buf_t nodeRb_read_alloc(uv_stream_t* handle, size_t suggested_size) {
+uv_buf_t nodeRb_read_alloc(uv_handle_t* handle, size_t suggested_size) {
     uv_buf_t buf;
     buf.base = (char*) malloc(suggested_size);
     buf.len = suggested_size;
     return buf;
 }
 
+void nodeRb_on_close(uv_handle_t* client) {
+    free(client->data);
+    free(client);
+}
+
 // Called when data read from stream
 void nodeRb_read(uv_stream_t* uv_handle, ssize_t nread, uv_buf_t buf) {
     nodeRb_basic_handle* handle = (nodeRb_basic_handle*) uv_handle->data;
     if (nread < 0) {
         if (buf.base) {
             free(buf.base);
+            //uv_close((uv_handle_t*) uv_handle, nodeRb_on_close);
         }
         return;
     }
@@ -27,8 +33,13 @@ void nodeRb_read(uv_stream_t* uv_handle, ssize_t nread, uv_buf_t buf) {
         free(buf.base);
         return;
     }
-    rb_funcall(nodeRb_get_class_from_id(handle->target), rb_intern(handle->target_callback), 1, rb_str_new(buf.base, nread));
-    free(buf.base);
+    if(handle->proxy_enabled == 1){
+        nodeRb_write(uv_handle, buf.base, nread);
+    }else{
+        rb_funcall(nodeRb_get_class_from_id(handle->target), rb_intern(handle->target_callback), 1, rb_str_new(buf.base, nread));
+        free(buf.base);
+    }
+
 }
 
 // Requests write to stream
@@ -45,13 +56,36 @@ void nodeRb_write(uv_stream_t* handle, char* data, size_t len){
 // Called after data written to stream
 void nodeRb_after_write(uv_write_t* req, int status) {
     if (status) {
-        uv_err_t err = uv_last_error();
+        uv_err_t err = uv_last_error(uv_default_loop());
         fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
     }
     write_req_t* wr = (write_req_t*) req;
     free(wr);
 }
 
+VALUE nodeRb_startProxy(VALUE self, VALUE source, VALUE target){
+    // Read data saved in Ruby
+    uv_stream_t *source_handle;
+    Data_Get_Struct(rb_iv_get(source, "@_proxy_target"), uv_stream_t, source_handle);
+    uv_stream_t *target_handle;
+    Data_Get_Struct(rb_iv_get(target, "@_proxy_target"), uv_stream_t, target_handle);
+    // Get internal structures
+    nodeRb_basic_handle* data = (nodeRb_basic_handle*) source_handle->data;
+    // Enable proxy
+    data->proxy_enabled = 1;
+    data->proxy_target = target_handle;
+}
+
+VALUE nodeRb_stopProxy(VALUE self, VALUE source){
+    // Read data saved in Ruby
+    uv_stream_t *source_handle;
+    Data_Get_Struct(rb_iv_get(source, "@_proxy_target"), uv_stream_t, source_handle);
+    // Get internal structures
+    nodeRb_basic_handle* data = (nodeRb_basic_handle*) source_handle->data;
+    // Disable proxy
+    data->proxy_enabled = 0;
+}
+
 /*
     NodeRb.next_tick runs block of code on the next iteration of the loop
 */
@@ -71,7 +105,7 @@ void nodeRb_next_tick(uv_idle_t* handle, int status) {
 VALUE nodeRb_nextTick(VALUE self) {
     if(nodeRbNextTickStatus == 0){
         uv_idle_t* handle = malloc(sizeof(uv_idle_t));
-        uv_idle_init(handle);
+        uv_idle_init(uv_default_loop(), handle);
         nodeRbNextTickStatus = 1;
         uv_idle_start(handle, nodeRb_next_tick);
     }
@@ -109,7 +143,7 @@ VALUE nodeRb_get_class_from_id(long id) {
 // Used for handling errors inside NodeRb
 int nodeRb_handle_error(int e) {
     if (e) {
-        uv_err_t error = uv_last_error();
+        uv_err_t error = uv_last_error(uv_default_loop());
         fprintf(stderr, "%s\n", uv_strerror(error));
         return 1;
     } else {
@@ -119,9 +153,9 @@ int nodeRb_handle_error(int e) {
 
 // Starts the event loop and adds one reference to ensure loop will run
 VALUE nodeRb_start(VALUE self) {
-    uv_ref();
+    uv_ref(uv_default_loop());
     if (rb_block_given_p()) {
         rb_yield(Qnil);
     }
-    uv_run();
+    uv_run(uv_default_loop());
 };

data/ext/noderb_extension/noderb_tools.h

@@ -20,10 +20,12 @@ typedef struct {
     uv_buf_t buf;
 } write_req_t;
 
-uv_buf_t nodeRb_read_alloc(uv_stream_t* handle, size_t suggested_size);
+uv_buf_t nodeRb_read_alloc(uv_handle_t* handle, size_t suggested_size);
 void nodeRb_read(uv_stream_t* uv_handle, ssize_t nread, uv_buf_t buf);
 void nodeRb_write(uv_stream_t* handle, char* data, size_t len);
 void nodeRb_after_write(uv_write_t* req, int status);
+VALUE nodeRb_startProxy(VALUE self, VALUE source, VALUE target);
+VALUE nodeRb_stopProxy(VALUE self, VALUE source);
 
 #ifdef	__cplusplus
 }

data/lib/noderb/defer.rb

@@ -0,0 +1,25 @@
+module NodeRb
+
+  class BackWorker < Thread
+
+    def initialize block
+      super do
+        block.call
+      end
+    end
+
+  end
+
+  class << self
+
+    def defer work = nil, callback = nil, &block
+      work = block if not work and block
+      callback = block if not callback and block
+      work ||= proc { }
+      callback ||= proc { |result| }
+      NodeRb.defer_native(BackWorker.new(work), callback)
+    end
+
+  end
+
+end