rbuv 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c9d6903efbe33b48ef3d2deb2cee18173a708ab2
-  data.tar.gz: dcb456920a095dfc229137299eaa597bf19b2948
+  metadata.gz: 308a6259f4457d5dd3ccd17dfd092940a75359ca
+  data.tar.gz: b8f8ef7b0a3aca6e69539fe09d047fc865f46614
 SHA512:
-  metadata.gz: 561fc7896938cee33ceff8d502d8ca96ed53f12c0109f9f9b454d806de3b379d7784912b93ce410f2b8479c06dd9c3d5341e9a7516d63adf5057ef5cfb37254d
-  data.tar.gz: 573137d980ae1f9a77d3d251f424c1f2c12d6e188d4b2586a02b8d33e143dd240430ed279d4b9f5279ea3e413547ac3340fba2effafae662c55808e5b912340d
+  metadata.gz: d9d906a50927d5e8c81439cce4f73a800e2e86812050dcfb91dda274a4ba4ef78bb69e06fc301f3fdfb66dbb63580d41d4b86a1e2be25cd1e09295e815132fde
+  data.tar.gz: 1b784c9a54821db879f02335f17067d59d90176c5618bb0e571c8cd2591f51043fbc05f0184db052e0f1c323b65be16783ee50acbf580c8931b8ceaa01d172da

data/.gitignore

@@ -20,3 +20,5 @@ rbuv.bundle
 coverage/
 xcode/
 .rbx/
+.ruby-gemset
+.ruby-version

data/ext/rbuv/extconf.rb

@@ -1,6 +1,9 @@
 require 'mkmf'
 require 'rbconfig'
 
+have_header('ruby/thread.h')
+have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
+
 case RbConfig::CONFIG["host_os"]
 when /darwin/
   have_framework("CoreFoundation")

data/ext/rbuv/rbuv.c

@@ -12,4 +12,7 @@ void Init_rbuv() {
   Init_rbuv_handle();
   Init_rbuv_loop();
   Init_rbuv_timer();
+  Init_rbuv_stream();
+  Init_rbuv_tcp();
+  Init_rbuv_signal();
 }

data/ext/rbuv/rbuv.h

@@ -4,14 +4,20 @@
 #include <assert.h>
 
 #include <ruby.h>
+#ifdef HAVE_RUBY_THREAD_H
+# include <ruby/thread.h>
+#endif
 #include <uv.h>
 
-#include "debug.h"
+#include "rbuv_debug.h"
 
-#include "error.h"
-#include "handle.h"
-#include "loop.h"
-#include "timer.h"
+#include "rbuv_error.h"
+#include "rbuv_handle.h"
+#include "rbuv_loop.h"
+#include "rbuv_timer.h"
+#include "rbuv_stream.h"
+#include "rbuv_tcp.h"
+#include "rbuv_signal.h"
 
 extern ID id_call;
 
@@ -24,4 +30,11 @@ extern VALUE mRbuv;
   } \
 } while(0)
 
-#endif  /* RBUV_H_ */
+#define RBUV_OFFSETOF(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#define RBUV_CONTAINTER_OF(ptr, type, member) ({ \
+  const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+  (type *)( (char *)__mptr - RBUV_OFFSETOF(type, member) );})
+
+typedef void *(*rbuv_rb_blocking_function_t)(void *);
+
+#endif  /* RBUV_H_ */

data/ext/rbuv/{debug.h → rbuv_debug.h}

@@ -24,4 +24,4 @@
 
 # endif
 
-#endif  /* RBUV_DEBUG_H_ */
+#endif  /* RBUV_DEBUG_H_ */

data/ext/rbuv/{error.c → rbuv_error.c}

@@ -1,7 +1,7 @@
-#include "error.h"
+#include "rbuv_error.h"
 
 VALUE eRbuvError;
 
 void Init_rbuv_error() {
   eRbuvError = rb_define_class_under(mRbuv, "Error", rb_eStandardError);
-}
+}

data/ext/rbuv/{error.h → rbuv_error.h}

@@ -7,4 +7,4 @@ extern VALUE eRbuvError;
 
 void Init_rbuv_error();
 
-#endif  /* RBUV_ERROR_H_ */
+#endif  /* RBUV_ERROR_H_ */

data/ext/rbuv/rbuv_handle.c

@@ -0,0 +1,124 @@
+#include "rbuv_handle.h"
+
+struct rbuv_handle_s {
+  uv_handle_t *uv_handle;
+  VALUE cb_on_close;
+};
+
+typedef struct {
+  uv_handle_t *uv_handle;
+} _uv_handle_on_close_arg_t;
+
+VALUE cRbuvHandle;
+
+/* Methods */
+static VALUE rbuv_handle_close(VALUE self);
+static VALUE rbuv_handle_is_active(VALUE self);
+static VALUE rbuv_handle_is_closing(VALUE self);
+
+/* Private methods */
+static void _uv_handle_close(uv_handle_t *uv_handle);
+static void _uv_handle_on_close(uv_handle_t *uv_handle);
+static void _uv_handle_on_close_no_gvl(_uv_handle_on_close_arg_t *arg);
+
+void Init_rbuv_handle() {
+  cRbuvHandle = rb_define_class_under(mRbuv, "Handle", rb_cObject);
+  rb_undef_alloc_func(cRbuvHandle);
+  
+  rb_define_method(cRbuvHandle, "close", rbuv_handle_close, 0);
+  rb_define_method(cRbuvHandle, "active?", rbuv_handle_is_active, 0);
+  rb_define_method(cRbuvHandle, "closing?", rbuv_handle_is_closing, 0);
+}
+
+VALUE rbuv_handle_close(VALUE self) {
+  rbuv_handle_t *rbuv_handle;
+  VALUE block;
+
+  if (rb_block_given_p()) {
+    block = rb_block_proc();
+  } else {
+    block = Qnil;
+  }
+
+  Data_Get_Struct(self, rbuv_handle_t, rbuv_handle);
+
+  _rbuv_handle_close(rbuv_handle, block);
+
+  return Qnil;
+}
+
+VALUE rbuv_handle_is_active(VALUE self) {
+  rbuv_handle_t *rbuv_handle;
+  
+  Data_Get_Struct(self, rbuv_handle_t, rbuv_handle);
+  
+  return _rbuv_handle_is_active(rbuv_handle) ? Qtrue : Qfalse;
+}
+
+VALUE rbuv_handle_is_closing(VALUE self) {
+  rbuv_handle_t *rbuv_handle;
+
+  Data_Get_Struct(self, rbuv_handle_t, rbuv_handle);
+
+  return _rbuv_handle_is_closing(rbuv_handle) ? Qtrue : Qfalse;
+}
+
+int _rbuv_handle_is_active(rbuv_handle_t *rbuv_handle) {
+  assert(rbuv_handle);
+  return uv_is_active(rbuv_handle->uv_handle);
+}
+
+int _rbuv_handle_is_closing(rbuv_handle_t *rbuv_handle) {
+  assert(rbuv_handle);
+  return uv_is_closing(rbuv_handle->uv_handle);
+}
+
+void _rbuv_handle_close(rbuv_handle_t *rbuv_handle, VALUE block) {
+  assert(rbuv_handle);
+  RBUV_DEBUG_LOG_DETAIL("rbuv_handle: %p, uv_handle: %p, block: %s",
+                        rbuv_handle, rbuv_handle->uv_handle,
+                        RSTRING_PTR(rb_inspect(block)));
+  if (!_rbuv_handle_is_closing(rbuv_handle)) {
+    RBUV_DEBUG_LOG_DETAIL("closing rbuv_handle: %p, uv_handle: %p, block: %s",
+                          rbuv_handle, rbuv_handle->uv_handle,
+                          RSTRING_PTR(rb_inspect(block)));
+    rbuv_handle->cb_on_close = block;
+    _uv_handle_close(rbuv_handle->uv_handle);
+  }
+}
+
+void _uv_handle_close(uv_handle_t *uv_handle) {
+  assert(uv_handle);
+  uv_close(uv_handle, _uv_handle_on_close);
+}
+
+void _uv_handle_on_close(uv_handle_t *uv_handle) {
+  _uv_handle_on_close_arg_t arg = { .uv_handle = uv_handle };
+  rb_thread_call_with_gvl((rbuv_rb_blocking_function_t)_uv_handle_on_close_no_gvl, &arg);
+}
+
+void _uv_handle_on_close_no_gvl(_uv_handle_on_close_arg_t *arg) {
+  uv_handle_t *uv_handle = arg->uv_handle;
+
+  VALUE handle;
+  rbuv_handle_t *rbuv_handle;
+  VALUE on_close;
+
+  handle = (VALUE)uv_handle->data;
+
+  RBUV_DEBUG_LOG_DETAIL("uv_handle: %p, handle: %s",
+                        uv_handle, RSTRING_PTR(rb_inspect(handle)));
+
+  Data_Get_Struct(handle, rbuv_handle_t, rbuv_handle);
+
+  on_close = rbuv_handle->cb_on_close;
+  rbuv_handle->cb_on_close = Qnil;
+
+  RBUV_DEBUG_LOG_DETAIL("handle: %s, on_close: %s",
+                        RSTRING_PTR(rb_inspect(handle)),
+                        RSTRING_PTR(rb_inspect(on_close)));
+
+  if (RTEST(on_close)) {
+    rb_funcall(on_close, id_call, 1, handle);
+  }
+}

data/ext/rbuv/rbuv_handle.h

@@ -0,0 +1,16 @@
+#ifndef RBUV_HANDLE_H_
+#define RBUV_HANDLE_H_
+
+#include "rbuv.h"
+
+typedef struct rbuv_handle_s rbuv_handle_t;
+
+extern VALUE cRbuvHandle;
+
+void Init_rbuv_handle();
+
+int _rbuv_handle_is_active(rbuv_handle_t *rbuv_handle);
+int _rbuv_handle_is_closing(rbuv_handle_t *rbuv_handle);
+void _rbuv_handle_close(rbuv_handle_t *rbuv_handle, VALUE block);
+
+#endif  /* RBUV_HANDLE_H_ */

data/ext/rbuv/{loop.c → rbuv_loop.c}

@@ -1,9 +1,13 @@
-#include "loop.h"
+#include "rbuv_loop.h"
 
 struct rbuv_handle_s {
   uv_handle_t *uv_handle;
 };
 
+typedef struct {
+  int mode;
+} _rbuv_loop_run_arg_t;
+
 VALUE cRbuvLoop;
 
 /* Methods */
@@ -14,6 +18,7 @@ static VALUE rbuv_loop_s_run_nowait(VALUE klass);
 
 /* Private methods */
 static void _rbuv_loop_run(uv_run_mode mode);
+static void _rbuv_loop_run_no_gvl(_rbuv_loop_run_arg_t *arg);
 
 void Init_rbuv_loop() {
   cRbuvLoop = rb_define_class_under(mRbuv, "Loop", cRbuvHandle);
@@ -46,5 +51,16 @@ VALUE rbuv_loop_s_run_nowait(VALUE klass) {
 }
 
 void _rbuv_loop_run(uv_run_mode mode) {
-  uv_run(uv_default_loop(), mode);
+  _rbuv_loop_run_arg_t arg = { .mode = mode };
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+  rb_thread_call_without_gvl((rbuv_rb_blocking_function_t)_rbuv_loop_run_no_gvl,
+                             &arg, RUBY_UBF_IO, 0);
+#else
+  rb_thread_blocking_region((rb_blocking_function_t *)_rbuv_loop_run_no_gvl,
+                            &arg, RUBY_UBF_IO, 0);
+#endif
+}
+
+void _rbuv_loop_run_no_gvl(_rbuv_loop_run_arg_t *arg) {
+  uv_run(uv_default_loop(), arg->mode);
 }

data/ext/rbuv/{loop.h → rbuv_loop.h}

@@ -2,7 +2,6 @@
 #define RBUV_LOOP_H_
 
 #include "rbuv.h"
-#include "handle.h"
 
 typedef struct rbuv_loop_s rbuv_loop_t;
 
@@ -10,4 +9,4 @@ extern VALUE cRbuvLoop;
 
 void Init_rbuv_loop();
 
-#endif  /* RBUV_LOOP_H_ */
+#endif  /* RBUV_LOOP_H_ */

data/ext/rbuv/rbuv_signal.c

@@ -0,0 +1,119 @@
+#include "rbuv_signal.h"
+
+struct rbuv_signal_s {
+  uv_signal_t *uv_handle;
+  VALUE cb_on_signal;
+};
+
+typedef struct _uv_signal_on_signal_no_gvl_arg_s {
+  uv_signal_t *uv_signal;
+  int signum;
+} _uv_signal_on_signal_no_gvl_arg_t;
+
+VALUE cRbuvSignal;
+
+/* Allocator/deallocator */
+static VALUE rbuv_signal_alloc(VALUE klass);
+static void rbuv_signal_mark(rbuv_signal_t *rbuv_signal);
+static void rbuv_signal_free(rbuv_signal_t *rbuv_signal);
+
+/* Methods */
+static VALUE rbuv_signal_start(VALUE self, VALUE signum);
+static VALUE rbuv_signal_stop(VALUE self);
+
+/* Private methods */
+static void _uv_signal_on_signal(uv_signal_t *uv_signal, int signum);
+static void _uv_signal_on_signal_no_gvl(_uv_signal_on_signal_no_gvl_arg_t *arg);
+
+void Init_rbuv_signal() {
+  cRbuvSignal = rb_define_class_under(mRbuv, "Signal", cRbuvHandle);
+  rb_define_alloc_func(cRbuvSignal, rbuv_signal_alloc);
+
+  rb_define_method(cRbuvSignal, "start", rbuv_signal_start, 1);
+  rb_define_method(cRbuvSignal, "stop", rbuv_signal_stop, 0);
+}
+
+VALUE rbuv_signal_alloc(VALUE klass) {
+  rbuv_signal_t *rbuv_signal;
+  VALUE signal;
+
+  rbuv_signal = malloc(sizeof(*rbuv_signal));
+  rbuv_signal->uv_handle = malloc(sizeof(*rbuv_signal->uv_handle));
+  uv_signal_init(uv_default_loop(), rbuv_signal->uv_handle);
+  rbuv_signal->cb_on_signal = Qnil;
+
+  signal = Data_Wrap_Struct(klass, rbuv_signal_mark, rbuv_signal_free, rbuv_signal);
+  rbuv_signal->uv_handle->data = (void *)signal;
+
+  RBUV_DEBUG_LOG_DETAIL("rbuv_signal: %p, uv_handle: %p, signal: %s",
+                        rbuv_signal, rbuv_signal->uv_handle,
+                        RSTRING_PTR(rb_inspect(signal)));
+
+  return signal;
+}
+
+void rbuv_signal_mark(rbuv_signal_t *rbuv_signal) {
+  assert(rbuv_signal);
+  RBUV_DEBUG_LOG_DETAIL("rbuv_signal: %p, uv_handle: %p, self: %lx",
+                        rbuv_signal, rbuv_signal->uv_handle,
+                        (VALUE)rbuv_signal->uv_handle->data);
+  rb_gc_mark(rbuv_signal->cb_on_signal);
+}
+
+void rbuv_signal_free(rbuv_signal_t *rbuv_signal) {
+  RBUV_DEBUG_LOG_DETAIL("rbuv_signal: %p, uv_handle: %p", rbuv_signal, rbuv_signal->uv_handle);
+
+  if (!_rbuv_handle_is_closing((rbuv_handle_t *)rbuv_signal)) {
+    uv_close((uv_handle_t *)rbuv_signal->uv_handle, NULL);
+  }
+
+  free(rbuv_signal);
+}
+
+VALUE rbuv_signal_start(VALUE self, VALUE signum) {
+  VALUE block;
+  int uv_signum;
+  rbuv_signal_t *rbuv_signal;
+
+  rb_need_block();
+  block = rb_block_proc();
+  uv_signum = NUM2INT(signum);
+
+  Data_Get_Struct(self, rbuv_signal_t, rbuv_signal);
+  rbuv_signal->cb_on_signal = block;
+
+  RBUV_DEBUG_LOG_DETAIL("rbuv_signal: %p, uv_handle: %p, _uv_signal_on_signal: %p, signal: %s",
+                        rbuv_signal, rbuv_signal->uv_handle, _uv_signal_on_signal,
+                        RSTRING_PTR(rb_inspect(self)));
+  uv_signal_start(rbuv_signal->uv_handle, _uv_signal_on_signal, uv_signum);
+
+  return self;
+}
+
+VALUE rbuv_signal_stop(VALUE self) {
+  rbuv_signal_t *rbuv_signal;
+
+  Data_Get_Struct(self, rbuv_signal_t, rbuv_signal);
+
+  uv_signal_stop(rbuv_signal->uv_handle);
+
+  return self;
+}
+
+void _uv_signal_on_signal(uv_signal_t *uv_signal, int signum) {
+  _uv_signal_on_signal_no_gvl_arg_t reg = { .uv_signal = uv_signal, .signum = signum };
+  rb_thread_call_with_gvl((rbuv_rb_blocking_function_t)_uv_signal_on_signal_no_gvl, &reg);
+}
+
+void _uv_signal_on_signal_no_gvl(_uv_signal_on_signal_no_gvl_arg_t *arg) {
+  uv_signal_t *uv_signal = arg->uv_signal;
+  int signum = arg->signum;
+
+  VALUE signal;
+  rbuv_signal_t *rbuv_signal;
+
+  signal = (VALUE)uv_signal->data;
+  Data_Get_Struct(signal, struct rbuv_signal_s, rbuv_signal);
+
+  rb_funcall(rbuv_signal->cb_on_signal, id_call, 2, signal, INT2FIX(signum));
+}

data/ext/rbuv/rbuv_signal.h

@@ -0,0 +1,12 @@
+#ifndef RBUV_SIGNAL_H_
+#define RBUV_SIGNAL_H_
+
+#include "rbuv.h"
+
+typedef struct rbuv_signal_s rbuv_signal_t;
+
+extern VALUE cRbuvSignal;
+
+void Init_rbuv_signal();
+
+#endif  /* RBUV_SIGNAL_H_ */

data/ext/rbuv/rbuv_stream.c

@@ -0,0 +1,253 @@
+#include "rbuv_stream.h"
+
+struct rbuv_stream_s {
+  uv_stream_t *uv_handle;
+  VALUE cb_on_close;
+  VALUE cb_on_connection;
+  VALUE cb_on_read;
+};
+
+typedef struct {
+  uv_write_t req;
+  uv_buf_t buf;
+} rbuv_write_req_t;
+
+typedef struct {
+  uv_stream_t *uv_stream;
+  int status;
+} _uv_stream_on_connection_arg_t;
+
+typedef struct {
+  uv_stream_t *uv_stream;
+  ssize_t nread;
+  uv_buf_t *buf;
+} _uv_stream_on_read_arg_t;
+
+VALUE cRbuvStream;
+
+/* Methods */
+static VALUE rbuv_stream_listen(VALUE self, VALUE backlog);
+static VALUE rbuv_stream_accept(VALUE self, VALUE client);
+static VALUE rbuv_stream_is_readable(VALUE self);
+static VALUE rbuv_stream_is_writable(VALUE self);
+static VALUE rbuv_stream_shutdown(VALUE self);
+static VALUE rbuv_stream_read_start(VALUE self);
+//static VALUE rbuv_stream_read2_start(VALUE self, VALUE client);
+static VALUE rbuv_stream_read_stop(VALUE self);
+static VALUE rbuv_stream_write(VALUE self, VALUE data);
+//static VALUE rbuv_stream_write2(VALUE self);
+
+/* Private methods */
+static void _uv_stream_on_connection(uv_stream_t *server, int status);
+static void _uv_stream_on_connection_no_gvl(_uv_stream_on_connection_arg_t *arg);
+static uv_buf_t _uv_alloc_buffer(uv_handle_t *handle, size_t suggested_size);
+static void _uv_stream_on_read(uv_stream_t *stream, ssize_t nread, uv_buf_t buf);
+static void _uv_stream_on_read_no_gvl(_uv_stream_on_read_arg_t *arg);
+static void _uv_stream_on_write(uv_write_t *req, int status);
+
+void Init_rbuv_stream() {
+  cRbuvStream = rb_define_class_under(mRbuv, "Stream", cRbuvHandle);
+  rb_undef_alloc_func(cRbuvStream);
+  
+  rb_define_method(cRbuvStream, "listen", rbuv_stream_listen, 1);
+  rb_define_method(cRbuvStream, "accept", rbuv_stream_accept, 1);
+  rb_define_method(cRbuvStream, "readable?", rbuv_stream_is_readable, 0);
+  rb_define_method(cRbuvStream, "writable?", rbuv_stream_is_writable, 0);
+  rb_define_method(cRbuvStream, "shutdown", rbuv_stream_shutdown, 0);
+  rb_define_method(cRbuvStream, "read_start", rbuv_stream_read_start, 0);
+//  rb_define_method(cRbuvStream, "read2_start", rbuv_stream_read2_start, 0);
+  rb_define_method(cRbuvStream, "read_stop", rbuv_stream_read_stop, 0);
+  rb_define_method(cRbuvStream, "write", rbuv_stream_write, 1);
+//  rb_define_method(cRbuvStream, "write2", rbuv_stream_write2, 1);
+}
+
+VALUE rbuv_stream_listen(VALUE self, VALUE backlog) {
+  rbuv_stream_t *rbuv_server;
+  VALUE block;
+  int uv_backlog;
+  
+  rb_need_block();
+  block = rb_block_proc();
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_server);
+  rbuv_server->cb_on_connection = block;
+  
+  uv_backlog = FIX2INT(backlog);
+  
+  RBUV_DEBUG_LOG_DETAIL("self: %s, backlog: %d, block: %s, rbuv_server: %p, "
+                        "uv_handle: %p, _uv_stream_on_connection: %p",
+                        RSTRING_PTR(rb_inspect(self)),
+                        uv_backlog,
+                        RSTRING_PTR(rb_inspect(block)),
+                        rbuv_server,
+                        rbuv_server->uv_handle,
+                        _uv_stream_on_connection);
+  RBUV_CHECK_UV_RETURN(uv_listen(rbuv_server->uv_handle, uv_backlog, _uv_stream_on_connection));
+  
+  return self;
+}
+
+VALUE rbuv_stream_accept(VALUE self, VALUE client) {
+  rbuv_stream_t *rbuv_server;
+  rbuv_stream_t *rbuv_client;
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_server);
+  Data_Get_Struct(client, rbuv_stream_t, rbuv_client);
+  
+  RBUV_CHECK_UV_RETURN(uv_accept(rbuv_server->uv_handle, rbuv_client->uv_handle));
+  
+  return self;
+}
+
+VALUE rbuv_stream_is_readable(VALUE self) {
+  rbuv_stream_t *rbuv_stream;
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+  
+  return uv_is_readable(rbuv_stream->uv_handle) ? Qtrue : Qfalse;
+}
+
+VALUE rbuv_stream_is_writable(VALUE self) {
+  rbuv_stream_t *rbuv_stream;
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+  
+  return uv_is_writable(rbuv_stream->uv_handle) ? Qtrue : Qfalse;
+}
+
+VALUE rbuv_stream_shutdown(VALUE self) {
+  rbuv_stream_t *rbuv_stream;
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+  
+  rb_raise(rb_eNotImpError, __func__);
+  
+  return self;
+}
+
+VALUE rbuv_stream_read_start(VALUE self) {
+  rbuv_stream_t *rbuv_stream;
+  VALUE block;
+  
+  rb_need_block();
+  block = rb_block_proc();
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+  rbuv_stream->cb_on_read = block;
+  
+  uv_read_start(rbuv_stream->uv_handle, _uv_alloc_buffer, _uv_stream_on_read);
+  
+  return self;
+}
+
+VALUE rbuv_stream_read_stop(VALUE self) {
+  rbuv_stream_t *rbuv_stream;
+
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+
+  uv_read_stop(rbuv_stream->uv_handle);
+
+  return self;
+}
+
+VALUE rbuv_stream_write(VALUE self, VALUE data) {
+  rbuv_stream_t *rbuv_stream;
+  rbuv_write_req_t *req;
+  
+  Data_Get_Struct(self, rbuv_stream_t, rbuv_stream);
+  
+  req = malloc(sizeof(*req));
+  
+  req->buf = uv_buf_init((char *)malloc(RSTRING_LEN(data)), (unsigned int)RSTRING_LEN(data));
+  memcpy(req->buf.base, RSTRING_PTR(data), RSTRING_LEN(data));
+  
+  uv_write(&req->req, rbuv_stream->uv_handle, &req->buf, 1, _uv_stream_on_write);
+  
+  return data;
+}
+
+void _uv_stream_on_connection(uv_stream_t *uv_server, int status) {
+  _uv_stream_on_connection_arg_t arg = { .uv_stream = uv_server, .status = status };
+  rb_thread_call_with_gvl((rbuv_rb_blocking_function_t)_uv_stream_on_connection_no_gvl, &arg);
+}
+
+void _uv_stream_on_connection_no_gvl(_uv_stream_on_connection_arg_t *arg) {
+  uv_stream_t *uv_server = arg->uv_stream;
+  int status = arg->status;
+
+  VALUE server;
+  rbuv_stream_t *rbuv_server;
+  VALUE on_connection;
+  
+  RBUV_DEBUG_LOG("uv_server: %p, status: %d", uv_server, status);
+  if (status == -1) {
+    return;
+  }
+  
+  server = (VALUE)uv_server->data;
+  Data_Get_Struct(server, rbuv_stream_t, rbuv_server);
+  on_connection = rbuv_server->cb_on_connection;
+  
+  RBUV_DEBUG_LOG_DETAIL("server: %s, on_connection: %s",
+                        RSTRING_PTR(rb_inspect(server)),
+                        RSTRING_PTR(rb_inspect(on_connection)));
+  
+  rb_funcall(on_connection, id_call, 1, server);
+}
+
+uv_buf_t _uv_alloc_buffer(uv_handle_t *handle, size_t suggested_size) {
+  return uv_buf_init((char *)malloc(suggested_size), (unsigned int)suggested_size);
+}
+
+void _uv_stream_on_read(uv_stream_t *uv_stream, ssize_t nread, uv_buf_t buf) {
+  _uv_stream_on_read_arg_t arg = { .uv_stream = uv_stream, .nread = nread, .buf = &buf };
+  rb_thread_call_with_gvl((rbuv_rb_blocking_function_t)_uv_stream_on_read_no_gvl, &arg);
+}
+
+void _uv_stream_on_read_no_gvl(_uv_stream_on_read_arg_t *arg) {
+  uv_stream_t *uv_stream = arg->uv_stream;
+  ssize_t nread = arg->nread;
+  uv_buf_t *buf = arg->buf;
+
+  VALUE stream;
+  rbuv_stream_t *rbuv_stream;
+  VALUE on_read;
+  uv_err_t uv_err;
+  VALUE error;
+
+  RBUV_DEBUG_LOG("uv_stream: %p, nread: %s", uv_stream, RSTRING_PTR(rb_inspect(nread)));
+
+  stream = (VALUE)uv_stream->data;
+  Data_Get_Struct(stream, rbuv_stream_t, rbuv_stream);
+  on_read = rbuv_stream->cb_on_read;
+  RBUV_DEBUG_LOG_DETAIL("stream: %s, on_read: %s",
+                        RSTRING_PTR(rb_inspect(stream)),
+                        RSTRING_PTR(rb_inspect(on_read)));
+
+  if (nread > 0) {
+    rb_funcall(on_read, id_call, 1, rb_str_new(buf->base, nread));
+  } else {
+    uv_err = uv_last_error(uv_default_loop());
+    if (uv_err.code == UV_EOF) {
+      error = rb_exc_new2(rb_eEOFError, "end of file reached");
+    } else {
+      error = rb_exc_new2(eRbuvError, uv_strerror(uv_err));
+    }
+    rb_funcall(on_read, id_call, 2, Qnil, error);
+  }
+
+  assert(buf->base);
+  free(buf->base);
+}
+
+void _uv_stream_on_write(uv_write_t *uv_req, int status) {
+  rbuv_write_req_t *rbuv_req;
+  RBUV_DEBUG_LOG("req: %p, status: %d", uv_req, status);
+
+  rbuv_req = RBUV_CONTAINTER_OF(uv_req, rbuv_write_req_t, req);
+
+  free(rbuv_req->buf.base);
+  free(rbuv_req);
+  
+  RBUV_CHECK_UV_RETURN(status);
+}

data/ext/rbuv/rbuv_stream.h

@@ -0,0 +1,12 @@
+#ifndef RBUV_STREAM_H_
+#define RBUV_STREAM_H_
+
+#include "rbuv.h"
+
+typedef struct rbuv_stream_s rbuv_stream_t;
+
+extern VALUE cRbuvStream;
+
+void Init_rbuv_stream();
+
+#endif  /* RBUV_STREAM_H_ */