rbuv 0.0.2 → 0.0.3

data/ext/rbuv/rbuv_tcp.c

@@ -0,0 +1,102 @@
+#include "rbuv_tcp.h"
+
+struct rbuv_tcp_s {
+  uv_tcp_t *uv_handle;
+  VALUE cb_on_close;
+  VALUE cb_on_connection;
+  VALUE cb_on_read;
+};
+
+VALUE cRbuvTcp;
+
+/* Allocator/deallocator */
+static VALUE rbuv_tcp_alloc(VALUE klass);
+static void rbuv_tcp_mark(rbuv_tcp_t *rbuv_tcp);
+static void rbuv_tcp_free(rbuv_tcp_t *rbuv_tcp);
+
+/* Methods */
+/*
+ uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in)
+ uv_tcp_bind6(uv_tcp_t* handle, struct sockaddr_in6)
+ uv_tcp_connect(uv_connect_t* req, uv_tcp_t* handle, struct sockaddr_in address, uv_connect❯
+ uv_tcp_connect6(uv_connect_t* req, uv_tcp_t* handle, struct sockaddr_in6 address, uv_conne❯
+ uv_tcp_getpeername(uv_tcp_t* handle, struct sockaddr* name, int* namelen)
+ uv_tcp_getsockname(uv_tcp_t* handle, struct sockaddr* name, int* namelen)
+ uv_tcp_init(uv_loop_t*, uv_tcp_t* handle)
+ uv_tcp_keepalive(uv_tcp_t* handle, int enable, unsigned int delay)
+ uv_tcp_nodelay(uv_tcp_t* handle, int enable)
+ uv_tcp_open(uv_tcp_t* handle, uv_os_sock_t sock)
+ uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable)
+ */
+static VALUE rbuv_tcp_bind(VALUE self, VALUE ip, VALUE port);
+//static VALUE rbuv_tcp_bind6(VALUE self, VALUE ip, VALUE port);
+
+void Init_rbuv_tcp() {
+  cRbuvTcp = rb_define_class_under(mRbuv, "Tcp", cRbuvStream);
+  rb_define_alloc_func(cRbuvTcp, rbuv_tcp_alloc);
+  
+  rb_define_method(cRbuvTcp, "bind", rbuv_tcp_bind, 2);
+  //rb_define_method(cRbuvTcp, "bind6", rbuv_tcp_bind6, 2);
+}
+
+VALUE rbuv_tcp_alloc(VALUE klass) {
+  rbuv_tcp_t *rbuv_tcp;
+  VALUE tcp;
+
+  rbuv_tcp = malloc(sizeof(*rbuv_tcp));
+  rbuv_tcp->uv_handle = malloc(sizeof(*rbuv_tcp->uv_handle));
+  uv_tcp_init(uv_default_loop(), rbuv_tcp->uv_handle);
+  rbuv_tcp->cb_on_close = Qnil;
+  rbuv_tcp->cb_on_connection = Qnil;
+  rbuv_tcp->cb_on_read = Qnil;
+  
+  tcp = Data_Wrap_Struct(klass, rbuv_tcp_mark, rbuv_tcp_free, rbuv_tcp);
+  rbuv_tcp->uv_handle->data = (void *)tcp;
+  
+  RBUV_DEBUG_LOG_DETAIL("rbuv_tcp: %p, uv_handle: %p, tcp: %s",
+                        rbuv_tcp, rbuv_tcp->uv_handle,
+                        RSTRING_PTR(rb_inspect(tcp)));
+  
+  return tcp;
+}
+
+void rbuv_tcp_mark(rbuv_tcp_t *rbuv_tcp) {
+  assert(rbuv_tcp);
+  RBUV_DEBUG_LOG_DETAIL("rbuv_tcp: %p, uv_handle: %p, self: %lx",
+                        rbuv_tcp, rbuv_tcp->uv_handle,
+                        (VALUE)rbuv_tcp->uv_handle->data);
+  rb_gc_mark(rbuv_tcp->cb_on_close);
+  rb_gc_mark(rbuv_tcp->cb_on_connection);
+  rb_gc_mark(rbuv_tcp->cb_on_read);
+}
+
+void rbuv_tcp_free(rbuv_tcp_t *rbuv_tcp) {
+  RBUV_DEBUG_LOG_DETAIL("rbuv_tcp: %p, uv_handle: %p", rbuv_tcp, rbuv_tcp->uv_handle);
+
+  if (!_rbuv_handle_is_closing((rbuv_handle_t *)rbuv_tcp)) {
+    uv_close((uv_handle_t *)rbuv_tcp->uv_handle, NULL);
+  }
+
+  free(rbuv_tcp);
+}
+
+VALUE rbuv_tcp_bind(VALUE self, VALUE ip, VALUE port) {
+  const char *uv_ip;
+  int uv_port;
+  rbuv_tcp_t *rbuv_tcp;
+  struct sockaddr_in bind_addr;
+  
+  uv_ip = RSTRING_PTR(ip);
+  uv_port = FIX2INT(port);
+  
+  bind_addr = uv_ip4_addr(uv_ip, uv_port);
+  
+  Data_Get_Struct(self, rbuv_tcp_t, rbuv_tcp);
+  RBUV_CHECK_UV_RETURN(uv_tcp_bind(rbuv_tcp->uv_handle, bind_addr));
+  
+  RBUV_DEBUG_LOG_DETAIL("self: %s, ip: %s, port: %d, rbuv_tcp: %p, uv_handle: %p",
+                        RSTRING_PTR(rb_inspect(self)), uv_ip, uv_port, rbuv_tcp,
+                        rbuv_tcp->uv_handle);
+  
+  return self;
+}

data/ext/rbuv/rbuv_tcp.h

@@ -0,0 +1,12 @@
+#ifndef RBUV_TCP_H_
+#define RBUV_TCP_H_
+
+#include "rbuv.h"
+
+typedef struct rbuv_tcp_s rbuv_tcp_t;
+
+extern VALUE cRbuvTcp;
+
+void Init_rbuv_tcp();
+
+#endif  /* RBUV_TCP_H_ */

data/ext/rbuv/{timer.c → rbuv_timer.c}

@@ -1,12 +1,18 @@
-#include "timer.h"
+#include "rbuv_timer.h"
 
 VALUE cRbuvTimer;
 
 struct rbuv_timer_s {
   uv_timer_t *uv_handle;
-  VALUE cb;
+  VALUE cb_on_close;
+  VALUE cb_on_timeout;
 };
 
+typedef struct {
+  uv_timer_t *uv_timer;
+  int status;
+} _uv_timer_on_timeout_no_gvl_arg_t;
+
 /* Allocator/deallocator */
 static VALUE rbuv_timer_alloc(VALUE klass);
 static void rbuv_timer_mark(rbuv_timer_t *rbuv_timer);
@@ -20,6 +26,7 @@ static VALUE rbuv_timer_repeat_set(VALUE self, VALUE repeat);
 
 /* Private methods */
 static void _uv_timer_on_timeout(uv_timer_t *uv_timer, int status);
+static void _uv_timer_on_timeout_no_gvl(_uv_timer_on_timeout_no_gvl_arg_t *arg);
 
 void Init_rbuv_timer() {
   cRbuvTimer = rb_define_class_under(mRbuv, "Timer", cRbuvHandle);
@@ -38,7 +45,8 @@ VALUE rbuv_timer_alloc(VALUE klass) {
   rbuv_timer = malloc(sizeof(*rbuv_timer));
   rbuv_timer->uv_handle = malloc(sizeof(*rbuv_timer->uv_handle));
   uv_timer_init(uv_default_loop(), rbuv_timer->uv_handle);
-  rbuv_timer->cb = Qnil;
+  rbuv_timer->cb_on_close = Qnil;
+  rbuv_timer->cb_on_timeout = Qnil;
 
   timer = Data_Wrap_Struct(klass, rbuv_timer_mark, rbuv_timer_free, rbuv_timer);
   rbuv_timer->uv_handle->data = (void *)timer;
@@ -48,12 +56,16 @@ VALUE rbuv_timer_alloc(VALUE klass) {
 
 void rbuv_timer_mark(rbuv_timer_t *rbuv_timer) {
   assert(rbuv_timer);
-  rb_gc_mark(rbuv_timer->cb);
+  rb_gc_mark(rbuv_timer->cb_on_close);
+  rb_gc_mark(rbuv_timer->cb_on_timeout);
 }
 
 void rbuv_timer_free(rbuv_timer_t *rbuv_timer) {
   assert(rbuv_timer);
-  rbuv_handle_close((rbuv_handle_t *)rbuv_timer);
+  RBUV_DEBUG_LOG_DETAIL("rbuv_timer: %p, uv_handle: %p", rbuv_timer, rbuv_timer->uv_handle);
+  if (!_rbuv_handle_is_closing((rbuv_handle_t *)rbuv_timer)) {
+    uv_close((uv_handle_t *)rbuv_timer->uv_handle, NULL);
+  }
   free(rbuv_timer);
 }
 
@@ -75,10 +87,11 @@ VALUE rbuv_timer_start(VALUE self, VALUE timeout, VALUE repeat) {
   uv_repeat = NUM2ULL(repeat);
   
   Data_Get_Struct(self, rbuv_timer_t, rbuv_timer);
-  rbuv_timer->cb = block;
+  rbuv_timer->cb_on_timeout = block;
   
-  RBUV_DEBUG_LOG_DETAIL("rbuv_timer: %p, uv_handle: %p, _uv_timer_on_timeout: %p, timer: %ld",
-                        rbuv_timer, rbuv_timer->uv_handle, _uv_timer_on_timeout, self);
+  RBUV_DEBUG_LOG_DETAIL("rbuv_timer: %p, uv_handle: %p, _uv_timer_on_timeout: %p, timer: %s",
+                        rbuv_timer, rbuv_timer->uv_handle, _uv_timer_on_timeout,
+                        RSTRING_PTR(rb_inspect(self)));
   uv_timer_start(rbuv_timer->uv_handle, _uv_timer_on_timeout,
                  uv_timeout, uv_repeat);
 
@@ -123,11 +136,19 @@ VALUE rbuv_timer_repeat_set(VALUE self, VALUE repeat) {
 }
 
 void _uv_timer_on_timeout(uv_timer_t *uv_timer, int status) {
+  _uv_timer_on_timeout_no_gvl_arg_t reg = { .uv_timer = uv_timer, .status = status };
+  rb_thread_call_with_gvl((rbuv_rb_blocking_function_t)_uv_timer_on_timeout_no_gvl, &reg);
+}
+
+void _uv_timer_on_timeout_no_gvl(_uv_timer_on_timeout_no_gvl_arg_t *arg) {
+  uv_timer_t *uv_timer = arg->uv_timer;
+  int status = arg->status;
+
   VALUE timer;
   rbuv_timer_t *rbuv_timer;
   
   timer = (VALUE)uv_timer->data;
   Data_Get_Struct(timer, struct rbuv_timer_s, rbuv_timer);
   
-  rb_funcall(rbuv_timer->cb, id_call, 1, timer);
-}
+  rb_funcall(rbuv_timer->cb_on_timeout, id_call, 1, timer);
+}

data/ext/rbuv/{timer.h → rbuv_timer.h}

@@ -2,7 +2,6 @@
 #define RBUV_TIMER_H_
 
 #include "rbuv.h"
-#include "handle.h"
 
 typedef struct rbuv_timer_s rbuv_timer_t;
 
@@ -10,4 +9,4 @@ extern VALUE cRbuvTimer;
 
 void Init_rbuv_timer();
 
-#endif  /* RBUV_TIMER_H_ */
+#endif  /* RBUV_TIMER_H_ */

data/lib/rbuv/signal.rb

@@ -0,0 +1,10 @@
+module Rbuv
+  class Signal
+    ::Signal.list.each do |signame, signum|
+      const_set signame, signum
+    end
+    def self.start(*args)
+      self.new.start(*args) { |*block_args| yield(*block_args) }
+    end
+  end
+end

data/lib/rbuv/timer.rb

@@ -1,7 +1,7 @@
 module Rbuv
   class Timer
     def self.start(*args)
-      Timer.new.start(*args) { |timer| yield timer }
+      self.new.start(*args) { |*block_args| yield(*block_args) }
     end
   end
 end

data/lib/rbuv/version.rb

@@ -1,3 +1,3 @@
 module Rbuv
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/rbuv.rb

@@ -1,27 +1,30 @@
 require 'rbuv/rbuv'
 require 'rbuv/version'
 require 'rbuv/timer'
+require 'rbuv/signal'
 
 module Rbuv
-  def self.run_loop
-    Loop.run
-  end
+  class << self
 
-  def self.stop_loop
-    Loop.stop
-  end
+    def run_loop
+      Loop.run
+    end
 
-  def self.run
-    Timer.start 0, 0 do
-      yield
+    def stop_loop
+      Loop.stop
     end
-    self.run_loop
-  end
 
-  def self.run_block
-    Timer.start 0, 0 do
-      yield
+    alias stop stop_loop
+
+    def run
+      Timer.start(0, 0) { yield }
+      self.run_loop
+    end
+
+    def run_block
+      Timer.start(0, 0) { yield }
+      Loop.run_once
     end
-    Loop.run_once
+
   end
 end

data/spec/signal_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rbuv::Signal do
+  it "#start" do
+    block = mock
+    block.should_receive(:call).once
+
+    Rbuv.run do
+      sig = Rbuv::Signal.new
+      sig.start 2 do
+        block.call
+        sig.close
+      end
+
+      Process.kill(2, Process.pid)
+    end
+  end
+
+  it "#stop" do
+    block = mock
+    block.should_receive(:call).once
+
+    Rbuv.run do
+      sig = Rbuv::Signal.new
+      sig.start 2 do
+        block.call
+        sig.stop
+      end
+
+      Process.kill(2, Process.pid)
+    end
+  end
+end

data/spec/tcp_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+require 'socket'
+
+def port_in_use?(port, host='127.0.0.1')
+  s = TCPServer.new host, port
+  s.close
+  false
+rescue Errno::EADDRINUSE
+  true
+end
+
+def port_alive?(port, host='127.0.0.1')
+  s = TCPSocket.new host, port
+  s.close
+  false
+rescue Errno::ECONNREFUSED
+  true
+end
+
+describe Rbuv::Tcp do
+  it { should be_a_kind_of Rbuv::Stream }
+
+  it "#bind" do
+    port_in_use?(60000).should be_false
+
+    Rbuv.run do
+      pending "this spec does't pass on linux machines, see #1 on github"
+      begin
+        tcp = Rbuv::Tcp.new
+        tcp.bind '127.0.0.1', 60000
+
+        port_in_use?(60000).should be_true
+      ensure
+        tcp.close
+      end
+
+      port_in_use?(60000).should be_false
+    end
+  end
+
+  context "#listen" do
+    it "when address not in use" do
+      port_in_use?(60000).should be_false
+
+      Rbuv.run do
+        begin
+          tcp = Rbuv::Tcp.new
+          tcp.bind '127.0.0.1', 60000
+          tcp.listen(10) { Rbuv.stop_loop }
+
+          port_in_use?(60000).should be_true
+        ensure
+          tcp.close
+        end
+
+        port_in_use?(60000).should be_false
+      end
+    end
+
+    it "when address already in use" do
+      port_in_use?(60000).should be_false
+
+      Rbuv.run do
+        begin
+          s = TCPServer.new '127.0.0.1', 60000
+
+          tcp = Rbuv::Tcp.new
+          tcp.bind '127.0.0.1', 60000
+          expect { tcp.listen(10) {} }.to raise_error
+        ensure
+          s.close
+          tcp.close
+        end
+      end
+    end
+
+    it "should call the on_connection callback when connection coming" do
+      on_connection = mock
+      on_connection.should_receive(:call).once
+
+      Rbuv.run do
+        tcp = Rbuv::Tcp.new
+        tcp.bind '127.0.0.1', 60000
+
+        tcp.listen(10) do
+          on_connection.call
+          tcp.close
+        end
+
+        sock = TCPSocket.new '127.0.0.1', 60000
+        sock.close
+      end
+    end
+  end
+
+  it "#accept" do
+    port_in_use?(60000).should be_false
+
+    Rbuv.run do
+      tcp = Rbuv::Tcp.new
+      tcp.bind '127.0.0.1', 60000
+
+      sock = nil
+
+      tcp.listen(10) do |s|
+        c = Rbuv::Tcp.new
+        expect { s.accept(c) }.not_to raise_error
+        sock.close
+        tcp.close
+      end
+
+      sock = TCPSocket.new '127.0.0.1', 60000
+    end
+  end
+
+  context "#close" do
+    it "affect #closing?" do
+      Rbuv.run do
+        tcp = Rbuv::Tcp.new
+        tcp.close do
+          tcp.closing?.should be_true
+        end
+        tcp.closing?.should be_true
+      end
+    end
+
+    it "call once" do
+      on_close = mock
+      on_close.should_receive(:call).once
+
+      Rbuv.run do
+        tcp = Rbuv::Tcp.new
+
+        tcp.close do
+          on_close.call
+        end
+      end
+    end
+
+    it "call multi-times" do
+      on_close = mock
+      on_close.should_receive(:call).once
+
+      no_on_close = mock
+      no_on_close.should_not_receive(:call)
+
+      Rbuv.run do
+        tcp = Rbuv::Tcp.new
+
+        tcp.close do
+          on_close.call
+        end
+
+        tcp.close do
+          no_on_close.call
+        end
+      end
+    end
+
+  end
+end