polyphony 0.40 → 0.43.2

data/ext/gyro/socket.c

@@ -1,213 +0,0 @@
-#include "gyro.h"
-#include <sys/socket.h>
-
-static VALUE cTCPSocket;
-
-///////////////////////////////////////////////////////////////////////////
-
-struct rsock_send_arg {
-    int fd, flags;
-    VALUE mesg;
-    struct sockaddr *to;
-    socklen_t tolen;
-};
-
-#define StringValue(v) rb_string_value(&(v))
-#define IS_ADDRINFO(obj) rb_typeddata_is_kind_of((obj), &addrinfo_type)
-
-VALUE
-rsock_sockaddr_string_value(volatile VALUE *v)
-{
-    // VALUE val = *v;
-    // if (IS_ADDRINFO(val)) {
-    //     *v = addrinfo_to_sockaddr(val);
-    // }
-    StringValue(*v);
-    return *v;
-}
-
-#define SockAddrStringValue(v) rsock_sockaddr_string_value(&(v))
-#define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
-#ifndef RSTRING_SOCKLEN
-#  define RSTRING_SOCKLEN (socklen_t)RSTRING_LENINT
-#endif
-
-#if defined __APPLE__
-# define do_write_retry(code) do {ret = code;} while (ret == -1 && errno == EPROTOTYPE)
-#else
-# define do_write_retry(code) ret = code
-#endif
-
-VALUE
-rsock_sendto_blocking(void *data)
-{
-    struct rsock_send_arg *arg = data;
-    VALUE mesg = arg->mesg;
-    ssize_t ret;
-    do_write_retry(sendto(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
-			  arg->flags, arg->to, arg->tolen));
-    return (VALUE)ret;
-}
-
-VALUE
-rsock_send_blocking(void *data)
-{
-    struct rsock_send_arg *arg = data;
-    VALUE mesg = arg->mesg;
-    ssize_t ret;
-    do_write_retry(send(arg->fd, RSTRING_PTR(mesg), RSTRING_LEN(mesg),
-			arg->flags));
-    return (VALUE)ret;
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-static VALUE BasicSocket_send(int argc, VALUE *argv, VALUE sock) {
-  VALUE underlying_socket = rb_iv_get(sock, "@io");
-  if (!NIL_P(underlying_socket)) sock = underlying_socket;
-  struct rsock_send_arg arg;
-  VALUE flags, to;
-  rb_io_t *fptr;
-  ssize_t n;
-  rb_blocking_function_t *func;
-  const char *funcname;
-  VALUE write_watcher = Qnil;
-
-  rb_scan_args(argc, argv, "21", &arg.mesg, &flags, &to);
-
-  StringValue(arg.mesg);
-
-  if (!NIL_P(to)) {
-    SockAddrStringValue(to);
-    to = rb_str_new4(to);
-    arg.to = (struct sockaddr *)RSTRING_PTR(to);
-    arg.tolen = RSTRING_SOCKLEN(to);
-    func = rsock_sendto_blocking;
-    funcname = "sendto(2)";
-  }
-  else {
-    func = rsock_send_blocking;
-    funcname = "send(2)";
-  }
-  GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
-  arg.fd = fptr->fd;
-  arg.flags = NUM2INT(flags);
-  while ((n = (ssize_t)func(&arg)) < 0) {
-    if (NIL_P(write_watcher))
-      write_watcher = Gyro_IO_auto_io(fptr->fd, EV_WRITE);
-    Gyro_IO_await(write_watcher);
-  }
-  return SSIZET2NUM(n);
-}
-
-static VALUE BasicSocket_recv(int argc, VALUE *argv, VALUE sock) {
-  VALUE underlying_socket = rb_iv_get(sock, "@io");
-  if (!NIL_P(underlying_socket)) sock = underlying_socket;
-  long len = argc >= 1 ? NUM2LONG(argv[0]) : 8192;
-  if (len < 0) {
-    rb_raise(rb_eArgError, "negative length %ld given", len);
-  }
-
-  rb_io_t *fptr;
-  long n;
-  int shrinkable;
-  VALUE read_watcher = Qnil;
-
-
-  VALUE str = argc >= 3 ? argv[2] : Qnil;
-
-  shrinkable = io_setstrbuf(&str, len);
-  OBJ_TAINT(str);
-  GetOpenFile(sock, fptr);
-  // rb_io_set_nonblock(fptr);
-  rb_io_check_byte_readable(fptr);
-
-  if (len == 0)
-  	return str;
-
-  while (1) {
-    n = recv(fptr->fd, RSTRING_PTR(str), len, MSG_DONTWAIT);
-    if (n < 0) {
-      int e = errno;
-      if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (NIL_P(read_watcher))
-          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
-        Gyro_IO_await(read_watcher);
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
-    }
-    else
-      break;
-  }
-
-  io_set_read_length(str, n, shrinkable);
-  io_enc_str(str, fptr);
-
-  if (n == 0)
-    return Qnil;
-
-  return str;
-}
-
-static VALUE Socket_accept(VALUE sock) {
-  rb_io_t *fptr;
-  int fd;
-  struct sockaddr addr;
-  socklen_t len = (socklen_t)sizeof addr;
-  VALUE read_watcher = Qnil;
-
-  GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
-
-  while (1) {
-    fd = accept(fptr->fd, &addr, &len);
-
-    if (fd < 0) {
-      int e = errno;
-      if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (NIL_P(read_watcher))
-          read_watcher = Gyro_IO_auto_io(fptr->fd, EV_READ);
-        Gyro_IO_await(read_watcher);
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
-    }
-    else {
-      VALUE connection = rb_obj_alloc(cTCPSocket);
-      rb_io_t *fp;
-      MakeOpenFile(connection, fp);
-      rb_update_max_fd(fd);
-      fp->fd = fd;
-      fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-      rb_io_ascii8bit_binmode(connection);
-      rb_io_set_nonblock(fp);
-      rb_io_synchronized(fp);
-      // if (rsock_do_not_reverse_lookup) {
-	    //   fp->mode |= FMODE_NOREVLOOKUP;
-      // }
-
-      return connection;
-    }
-  }
-}
-
-void Init_Socket() {
-  VALUE cBasicSocket;
-  VALUE cSocket;
-  
-  rb_require("socket");
-  cBasicSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
-
-  rb_define_method(cBasicSocket, "send", BasicSocket_send, -1);
-  rb_define_method(cBasicSocket, "recv", BasicSocket_recv, -1);
-
-  cSocket = rb_const_get(rb_cObject, rb_intern("Socket"));
-
-  rb_define_method(cSocket, "accept", Socket_accept, 0);
-
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
-}

data/ext/gyro/timer.c

@@ -1,115 +0,0 @@
-#include "gyro.h"
-
-struct Gyro_Timer {
-  GYRO_WATCHER_DECL(ev_timer);
-  double  after;
-  double  repeat;
-};
-
-VALUE cGyro_Timer = Qnil;
-
-static void Gyro_Timer_mark(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  GYRO_WATCHER_MARK(timer);
-}
-
-static void Gyro_Timer_free(void *ptr) {
-  struct Gyro_Timer *timer = ptr;
-  GYRO_WATCHER_FREE(timer);
-}
-
-static size_t Gyro_Timer_size(const void *ptr) {
-  return sizeof(struct Gyro_Timer);
-}
-
-static const rb_data_type_t Gyro_Timer_type = {
-    "Gyro_Timer",
-    {Gyro_Timer_mark, Gyro_Timer_free, Gyro_Timer_size,},
-    0, 0, 0
-};
-
-static VALUE Gyro_Timer_allocate(VALUE klass) {
-  struct Gyro_Timer *timer = ALLOC(struct Gyro_Timer);
-  return TypedData_Wrap_Struct(klass, &Gyro_Timer_type, timer);
-}
-
-#define GetGyro_Timer(obj, timer) \
-  TypedData_Get_Struct((obj), struct Gyro_Timer, &Gyro_Timer_type, (timer))
-
-inline void timer_activate(struct Gyro_Timer *timer) {
-  timer->fiber = rb_fiber_current();
-  timer->selector = Thread_current_event_selector();
-  timer->ev_loop = Gyro_Selector_ev_loop(timer->selector);
-
-  if (timer->active) return;
-
-  timer->active = 1;
-  Gyro_Selector_add_active_watcher(timer->selector, timer->self);
-  ev_timer_start(timer->ev_loop, &timer->ev_timer);
-}
-
-inline void timer_deactivate(struct Gyro_Timer *timer, int non_recurring_only) {
-  if (!timer->active) return;
-
-  if (!timer->repeat || !non_recurring_only) {
-    ev_timer_stop(timer->ev_loop, &timer->ev_timer);
-    if (RTEST(timer->selector)) {
-      Gyro_Selector_remove_active_watcher(timer->selector, timer->self);
-      timer->selector = Qnil;
-    }
-    timer->ev_loop = 0;
-    timer->active = 0;
-  }
-
-  timer->fiber = Qnil;
-}
-
-void Gyro_Timer_callback(struct ev_loop *ev_loop, struct ev_timer *ev_timer, int revents) {
-  struct Gyro_Timer *timer = (struct Gyro_Timer*)ev_timer;
-
-  Fiber_make_runnable(timer->fiber, DBL2NUM(timer->after));
-  timer_deactivate(timer, 1);
-}
-
-static VALUE Gyro_Timer_initialize(VALUE self, VALUE after, VALUE repeat) {
-  struct Gyro_Timer *timer;
-
-  GetGyro_Timer(self, timer);
-  GYRO_WATCHER_INITIALIZE(timer, self);
-  timer->after      = NUM2DBL(after);
-  timer->repeat     = NUM2DBL(repeat);
-  ev_timer_init(&timer->ev_timer, Gyro_Timer_callback, timer->after, timer->repeat);
-
-  return Qnil;
-}
-
-VALUE Gyro_Timer_stop(VALUE self) {
-  struct Gyro_Timer *timer;
-  GetGyro_Timer(self, timer);
-
-  timer_deactivate(timer, 0);
-  return self;
-}
-
-VALUE Gyro_Timer_await(VALUE self) {
-  struct Gyro_Timer *timer;
-  VALUE ret;
-  GetGyro_Timer(self, timer);
-
-  timer_activate(timer);
-  ret = Gyro_switchpoint();
-  timer_deactivate(timer, 1);
-
-  TEST_RESUME_EXCEPTION(ret);
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
-void Init_Gyro_Timer() {
-  cGyro_Timer = rb_define_class_under(mGyro, "Timer", rb_cData);
-  rb_define_alloc_func(cGyro_Timer, Gyro_Timer_allocate);
-
-  rb_define_method(cGyro_Timer, "initialize", Gyro_Timer_initialize, 2);
-  rb_define_method(cGyro_Timer, "await", Gyro_Timer_await, 0);
-  rb_define_method(cGyro_Timer, "stop", Gyro_Timer_stop, 0);
-}

data/test/test_timer.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TimerTest < MiniTest::Test
-  def test_that_one_shot_timer_works
-    count = 0
-    t = Gyro::Timer.new(0.01, 0)
-    spin {
-      t.await
-      count += 1
-    }
-    suspend
-    assert_equal 1, count
-  end
-
-  def test_that_repeating_timer_works
-    count = 0
-    t = Gyro::Timer.new(0.001, 0.001)
-    spin {
-      loop {
-        t.await
-        count += 1
-        break if count >= 3
-      }
-    }
-    suspend
-    assert_equal 3, count
-  ensure
-    t.stop
-  end
-
-  def test_that_repeating_timer_compensates_for_drift
-    count = 0
-    t = Gyro::Timer.new(0.1, 0.1)
-    deltas = []
-    last = nil
-    spin {
-      last = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      loop {
-        t.await
-        now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        elapsed = (now - last)
-        deltas << elapsed
-        last = now
-        count += 1
-        sleep 0.05
-        break if count >= 3
-      }
-    }
-    suspend
-    assert_equal 0, deltas[1..-1].filter { |d| (d - 0.1).abs >= 0.05 }.size
-  ensure
-    t.stop
-  end
-end