noderb 0.0.3 → 0.0.4

data/ext/noderb_extension/noderb_tcp.c

@@ -0,0 +1,127 @@
+#include <noderb_common.h>
+#include <noderb_tcp.h>
+
+#include <noderb.h>
+#include <noderb_tools.h>
+
+typedef struct {
+    NODERB_BASIC_HANDLE
+} nodeRb_client;
+
+/*
+    NodeRb TCP
+*/
+
+void nodeRb_tcp_on_close(uv_handle_t* client) {
+    // Read data saved in Ruby
+    nodeRb_client *client_data = client->data;
+    VALUE object = nodeRb_get_class_from_id(client_data->target);
+    // Call callback for connection close
+    rb_funcall(object, rb_intern("on_close"), 0, 0);
+    // Allow GC of handler instance
+    nodeRb_unregister_instance(object);
+    rb_iv_set(object, "@_handle", Qnil);
+    // Clean up some memory
+    free(client_data);
+    free(client);
+}
+
+void nodeRb_tcp_on_shutdown(uv_shutdown_t* req, int status) {
+    // When connection shutdown, close it
+    uv_close((uv_handle_t*) req->handle, nodeRb_tcp_on_close);
+    free(req);
+}
+
+VALUE nodeRb_tcp_close_connection(VALUE self) {
+    // Allocate new shutdown request
+    uv_shutdown_t* req = malloc(sizeof (uv_shutdown_t));
+    // Read data saved in Ruby
+    VALUE rhandler = rb_iv_get(self, "@_handle");
+    uv_stream_t *handle;
+    Data_Get_Struct(rhandler, uv_stream_t, handle);
+    // Request shutdown of stream
+    uv_shutdown(req, handle, nodeRb_tcp_on_shutdown);
+}
+
+VALUE nodeRb_tcp_send_data(VALUE self, VALUE data) {
+    // Read data saved in Ruby
+    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 TCP client
+*/
+
+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_funcall(obj, rb_intern("on_connect"), 0, 0);
+    uv_read_start((uv_stream_t*) client->handle, nodeRb_read_alloc, nodeRb_read);
+}
+
+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_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));
+    // Save client data
+    nodeRb_client *client_data = malloc(sizeof (nodeRb_client));
+    client_data->target = rb_num2long(rb_obj_id(clazz));
+    client_data->target_callback = (char*) "on_data";
+    handle->data = client_data;
+    // Open socket
+    int r = uv_tcp_connect(connect, handle, socket, nodeRb_tcp_on_client_connect);
+    if (nodeRb_handle_error(r)) return Qnil;
+};
+
+/*
+    NodeRb TCP server
+*/
+
+void nodeRb_tcp_on_server_connect(uv_stream_t* server, int status) {
+    // Allocate memory for client data
+    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);
+    // Accept connection
+    int r = uv_accept(server, client);
+    if (nodeRb_handle_error(r)) return;
+    // Initialise new instance of handler class
+    VALUE clazz = rb_path2class(server->data);
+    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));
+    // 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;
+    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);
+    // Translate IP address
+    struct sockaddr_in socket = uv_ip4_addr(rb_string_value_cstr(&address), (int) rb_num2long(port));
+    // Bind on socket
+    int r = uv_tcp_bind(server, socket);
+    if (nodeRb_handle_error(r)) return Qnil;
+    // Listen on server
+    r = uv_listen((uv_stream_t*) server, 128, nodeRb_tcp_on_server_connect);
+    if (nodeRb_handle_error(r)) return Qnil;
+    // Save information for server
+    VALUE name = rb_class_name(clazz);
+    server->data = rb_string_value_cstr(&name);
+};

data/ext/noderb_extension/noderb_tcp.h

@@ -0,0 +1,19 @@
+#ifndef NODERB_TCP_SERVER_H
+#define	NODERB_TCP_SERVER_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+VALUE nodeRb_tcp_startClient(VALUE self, VALUE address, VALUE port, VALUE clazz);
+
+VALUE nodeRb_tcp_startServer(VALUE self, VALUE address, VALUE port, VALUE clazz);
+VALUE nodeRb_tcp_send_data(VALUE self, VALUE data);
+VALUE nodeRb_tcp_close_connection(VALUE self);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* NODERB_TCP_SERVER_H */
+

data/ext/noderb_extension/noderb_timers.c

@@ -0,0 +1,58 @@
+#include <noderb_common.h>
+#include <noderb_timers.h>
+
+#include <noderb_tools.h>
+#include <noderb.h>
+
+typedef struct {
+    long target;
+    int repeat;
+} nodeRb_timers_handle;
+
+void nodeRb_timers_callback(uv_timer_t* handle, int status){
+    // Load data
+    nodeRb_timers_handle* data = (nodeRb_timers_handle*) handle->data;
+    VALUE handler = nodeRb_get_class_from_id(data->target);
+    // Run callback
+    rb_funcall(handler, rb_intern("call"), 1, handler);
+    if(data->repeat == 0){
+        // Let the GC work
+        nodeRb_unregister_instance(handler);
+        // Free memory
+        free(data);
+        free(handle);
+    }
+}
+
+VALUE nodeRb_timers_stop(VALUE self){
+    // Load data
+    uv_timer_t *handle;
+    Data_Get_Struct(rb_iv_get(self, "@_handle"), uv_timer_t, handle);
+    // Stop timer
+    uv_timer_stop(handle);
+    // Let the GC work
+    nodeRb_unregister_instance(self);
+    // Free memory
+    free((nodeRb_timers_handle*) handle->data);
+    free(handle);
+}
+
+VALUE nodeRb_timers_once(VALUE self, VALUE timeout, VALUE repeat, VALUE handler){
+    // Allocate memory
+    uv_timer_t* handle = (uv_timer_t*) malloc(sizeof(uv_timer_t));
+    nodeRb_timers_handle* data = (nodeRb_timers_handle*) malloc(sizeof(nodeRb_timers_handle));
+    // Save from GC
+    nodeRb_register_instance(handler);
+    // Save data for later use
+    if(rb_num2long(timeout) > 0){
+        data->repeat = 1;
+    }
+    data->target = rb_num2long(rb_obj_id(handler));
+    // Initialize
+    uv_timer_init(handle);
+    handle->data = data;
+    // Save handle
+    rb_iv_set(handler, "@_handle", Data_Wrap_Struct(nodeRb_get_nodeRb_pointer(), 0, NULL, handle));
+    // Schedule
+    uv_timer_start(handle, nodeRb_timers_callback, rb_num2long(timeout), rb_num2long(repeat));
+}

data/ext/noderb_extension/noderb_timers.h

@@ -0,0 +1,16 @@
+#ifndef NODERB_TIMERS_H
+#define	NODERB_TIMERS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+VALUE nodeRb_timers_once(VALUE self, VALUE timeout, VALUE repeat, VALUE callback);
+VALUE nodeRb_timers_stop(VALUE self);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* NODERB_TIMERS_H */
+

data/ext/noderb_extension/noderb_tools.c

@@ -0,0 +1,127 @@
+#include <noderb_common.h>
+#include <noderb_tools.h>
+#include <noderb.h>
+
+/*
+    Consolidate read and write request to allow cross-functionality like proxy
+*/
+
+// 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 buf;
+    buf.base = (char*) malloc(suggested_size);
+    buf.len = suggested_size;
+    return buf;
+}
+
+// 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);
+        }
+        return;
+    }
+    if (nread == 0) {
+        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);
+}
+
+// Requests write to stream
+void nodeRb_write(uv_stream_t* handle, char* data, size_t len){
+    if(handle->type != UV_TCP && handle->type != UV_NAMED_PIPE){
+        return;
+    }
+    write_req_t* wr = malloc(sizeof(write_req_t));
+    wr->buf.base = data;
+    wr->buf.len = len;
+    uv_write(&wr->req, handle, &wr->buf, 1, nodeRb_after_write);
+}
+
+// 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();
+        fprintf(stderr, "uv_write error: %s\n", uv_strerror(err));
+    }
+    write_req_t* wr = (write_req_t*) req;
+    free(wr);
+}
+
+/*
+    NodeRb.next_tick runs block of code on the next iteration of the loop
+*/
+
+// Indicator that we already have something to run
+int nodeRbNextTickStatus = 0;
+
+// Invoked by the loop to execute scheduled blocks in Ruby
+void nodeRb_next_tick(uv_idle_t* handle, int status) {
+    uv_idle_stop(handle);
+    free(handle);
+    nodeRbNextTickStatus = 0;
+    rb_funcall(nodeRb_get_nodeRb_module(), rb_intern("next_tick_execute"), 0);
+}
+
+// Schedules invocation on the next iteration if not already scheduled
+VALUE nodeRb_nextTick(VALUE self) {
+    if(nodeRbNextTickStatus == 0){
+        uv_idle_t* handle = malloc(sizeof(uv_idle_t));
+        uv_idle_init(handle);
+        nodeRbNextTickStatus = 1;
+        uv_idle_start(handle, nodeRb_next_tick);
+    }
+}
+
+/*
+    Tools to simplify NodeRb development
+*/
+
+// Register object to be GC safe
+VALUE nodeRb_register_instance(VALUE instance) {
+    rb_ary_push(rb_iv_get(nodeRb_get_nodeRb_module(), "@instances"), instance);
+}
+
+// Ruby wrapper for previous function
+VALUE nodeRb_registerInstance(VALUE self, VALUE instance) {
+    nodeRb_register_instance(instance);
+}
+
+// Unregister object to be GC safe
+VALUE nodeRb_unregister_instance(VALUE instance) {
+    rb_ary_delete(rb_iv_get(nodeRb_get_nodeRb_module(), "@instances"), instance);
+}
+
+// Ruby wrapper for previous function
+VALUE nodeRb_unregisterInstance(VALUE self, VALUE instance) {
+    nodeRb_unregister_instance(instance);
+}
+
+// Transforms Ruby Object.object_id back into the Object
+VALUE nodeRb_get_class_from_id(long id) {
+    return rb_funcall(rb_const_get(rb_cObject, rb_intern("ObjectSpace")), rb_intern("_id2ref"), 1, rb_int2inum(id));
+}
+
+// Used for handling errors inside NodeRb
+int nodeRb_handle_error(int e) {
+    if (e) {
+        uv_err_t error = uv_last_error();
+        fprintf(stderr, "%s\n", uv_strerror(error));
+        return 1;
+    } else {
+        return 0;
+    }
+};
+
+// Starts the event loop and adds one reference to ensure loop will run
+VALUE nodeRb_start(VALUE self) {
+    uv_ref();
+    if (rb_block_given_p()) {
+        rb_yield(Qnil);
+    }
+    uv_run();
+};

data/ext/noderb_extension/noderb_tools.h

@@ -0,0 +1,33 @@
+#ifndef NODERB_TOOLS_H
+#define	NODERB_TOOLS_H
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+VALUE nodeRb_nextTick(VALUE self);
+VALUE nodeRb_start(VALUE self);
+
+VALUE nodeRb_register_instance(VALUE instance);
+VALUE nodeRb_registerInstance(VALUE self, VALUE instance);
+VALUE nodeRb_unregister_instance(VALUE instance);
+VALUE nodeRb_unregisterInstance(VALUE self, VALUE instance);
+
+VALUE nodeRb_get_class_from_id(long id);
+
+typedef struct {
+    uv_write_t req;
+    uv_buf_t buf;
+} write_req_t;
+
+uv_buf_t nodeRb_read_alloc(uv_stream_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);
+
+#ifdef	__cplusplus
+}
+#endif
+
+#endif	/* NODERB_TOOLS_H */
+

data/lib/noderb/dns.rb

@@ -0,0 +1,11 @@
+module NodeRb
+
+  class << self
+
+    def resolve hostname, &block
+      NodeRb.resolve_native(hostname, block)
+    end
+
+  end
+
+end

data/lib/noderb/next_tick.rb

@@ -1,9 +1,10 @@
 module NodeRb
+
   class << self
     
     def next_tick &block
       ( @next_tick ||= [] ) << block
-      NodeRb.native_next_tick
+      NodeRb.send(:next_tick_native)
     end
     
     def next_tick_execute

data/lib/noderb/tcp.rb

@@ -0,0 +1,27 @@
+module NodeRb
+
+  class << self
+
+    def start_server address, port, clazz
+      if /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(address)
+        NodeRb.start_server_native(address, port, clazz)
+      else
+        NodeRb.resolve(address) do |ip|
+          NodeRb.start_server_native(ip, port, clazz)
+        end
+      end
+    end
+
+    def start_client address, port, clazz
+      if /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(address)
+        NodeRb.start_client_native(address, port, clazz)
+      else
+        NodeRb.resolve(address) do |ip|
+          NodeRb.start_client_native(ip, port, clazz)
+        end
+      end
+    end
+
+  end
+  
+end

data/lib/noderb/timers.rb

@@ -0,0 +1,24 @@
+module NodeRb
+
+  class << self
+
+    def once timeout, &block
+      NodeRb.once_native(timeout * 1000, 0, block)
+    end
+
+    def repeat repeat, handler, timeout = nil
+      timeout ||= repeat
+      NodeRb.once_native(timeout * 1000, repeat * 1000, handler)
+    end
+
+  end
+
+  module Timer
+
+    def call
+      
+    end
+
+  end
+
+end

data/lib/noderb/version.rb

@@ -1,3 +1,3 @@
 module NodeRb
-  VERSION = "0.0.3" unless const_defined?(:VERSION)
+  VERSION = "0.0.4" unless const_defined?(:VERSION)
 end

data/lib/noderb.rb

@@ -1,7 +1,12 @@
 # Native extension
 require "noderb_extension"
-# Ruby extension
+# Tools
 require "noderb/version"
 require "noderb/next_tick"
+require "noderb/timers"
+# System
+require "noderb/tcp"
+require "noderb/dns"
+# Helpers
 require "noderb/connection"
 require "noderb/process"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noderb
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-09 00:00:00.000000000Z
+date: 2011-08-19 00:00:00.000000000Z
 dependencies: []
 description: Port of the NodeJs library to Ruby, featuring asynchronous IO operations
   of all kinds.
@@ -21,15 +21,18 @@ extensions:
 extra_rdoc_files: []
 files:
 - lib/noderb/connection.rb
+- lib/noderb/dns.rb
 - lib/noderb/next_tick.rb
 - lib/noderb/process.rb
+- lib/noderb/tcp.rb
+- lib/noderb/timers.rb
 - lib/noderb/version.rb
 - lib/noderb.rb
 - ext/noderb_extension/extconf.rb
+- ext/noderb_extension/libuv/all.gyp
 - ext/noderb_extension/libuv/AUTHORS
-- ext/noderb_extension/libuv/build/all.gyp
-- ext/noderb_extension/libuv/build/common.gypi
-- ext/noderb_extension/libuv/build/gyp_uv
+- ext/noderb_extension/libuv/BSDmakefile
+- ext/noderb_extension/libuv/common.gypi
 - ext/noderb_extension/libuv/config-mingw.mk
 - ext/noderb_extension/libuv/config-unix.mk
 - ext/noderb_extension/libuv/create-msvs-files.bat
@@ -222,8 +225,8 @@ files:
 - ext/noderb_extension/libuv/deps/pthread-win32/version.rc
 - ext/noderb_extension/libuv/deps/pthread-win32/w32_CancelableWait.c
 - ext/noderb_extension/libuv/deps/pthread-win32/WinCE-PORT
-- ext/noderb_extension/libuv/doc/desired-api.md
 - ext/noderb_extension/libuv/doc/iocp-links.html
+- ext/noderb_extension/libuv/gyp_uv
 - ext/noderb_extension/libuv/include/ares.h
 - ext/noderb_extension/libuv/include/ares_version.h
 - ext/noderb_extension/libuv/include/eio.h
@@ -390,6 +393,7 @@ files:
 - ext/noderb_extension/libuv/src/win/handle.c
 - ext/noderb_extension/libuv/src/win/internal.h
 - ext/noderb_extension/libuv/src/win/loop-watcher.c
+- ext/noderb_extension/libuv/src/win/ntdll.h
 - ext/noderb_extension/libuv/src/win/pipe.c
 - ext/noderb_extension/libuv/src/win/process.c
 - ext/noderb_extension/libuv/src/win/req.c
@@ -398,6 +402,7 @@ files:
 - ext/noderb_extension/libuv/src/win/tcp.c
 - ext/noderb_extension/libuv/src/win/timer.c
 - ext/noderb_extension/libuv/src/win/util.c
+- ext/noderb_extension/libuv/src/win/winapi.c
 - ext/noderb_extension/libuv/test/benchmark-ares.c
 - ext/noderb_extension/libuv/test/benchmark-getaddrinfo.c
 - ext/noderb_extension/libuv/test/benchmark-list.h
@@ -443,6 +448,17 @@ files:
 - ext/noderb_extension/libuv/test/test-timer.c
 - ext/noderb_extension/noderb.c
 - ext/noderb_extension/noderb.h
+- ext/noderb_extension/noderb_common.h
+- ext/noderb_extension/noderb_dns.c
+- ext/noderb_extension/noderb_dns.h
+- ext/noderb_extension/noderb_process.c
+- ext/noderb_extension/noderb_process.h
+- ext/noderb_extension/noderb_tcp.c
+- ext/noderb_extension/noderb_tcp.h
+- ext/noderb_extension/noderb_timers.c
+- ext/noderb_extension/noderb_timers.h
+- ext/noderb_extension/noderb_tools.c
+- ext/noderb_extension/noderb_tools.h
 - LICENSE
 - README.md
 homepage: http://github.com/marekjelen/noderb
@@ -465,7 +481,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: noderb
-rubygems_version: 1.8.5
+rubygems_version: 1.8.8
 signing_key: 
 specification_version: 3
 summary: Port of the NodeJs library to Ruby