surro-gate 0.2.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a27ce2403acd4f16e3d9d0e67209773563b24e9d
-  data.tar.gz: d8eb8edee4f24b9b66c03cea8e0df9cb2f6542da
+SHA256:
+  metadata.gz: 542c462ea407735d332f61fd2a665ec27c151069c9b670da220592b30c4895bc
+  data.tar.gz: 17cf01b8d553093d77afb8409b995d06ff0351893431d35cf92afa079ae87247
 SHA512:
-  metadata.gz: '0801c6d8fa84ea67afab352c434fcbdcb56b0518ffe5886d372e371dc22ae35cc8de4571b23313ea18612d28c0d2f3e4889b4cee447573c1b8e64635a6ab8f0c'
-  data.tar.gz: 9b0324b3ca7638b9869285ea0993994fbabbf297f293eb0bd10b416fb37b4e2c77bc01ca75c7e9b92b7db8f042a906540ca5a94ecdbf237bcd0083ae1d55cd24
+  metadata.gz: 06d2cbf0cfab641f3006ab85c7baf48977b2b2bb05514b92cce2e990b35e31b34054b0b985cb9cc746f235bc764946e1c2d958c713a41e68a5c967508ece795b
+  data.tar.gz: a613ef079f5d878d5785139f2b215561252160f5f2bc1097ce13dce0eca47f063ac06a52d1e335df62bb1e08ec1eb117f56ef74ec93b858d5cb4ae6e6a4143ba

data/.gitignore

@@ -9,6 +9,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+/lib/**/*.so
 
 ## Documentation cache and generated files:
 /.yardoc/

data/.travis.yml

@@ -1,11 +1,18 @@
 sudo: false
 language: ruby
 cache: bundler
+os:
+  - linux
+  - osx
+compiler:
+  - gcc
+  - clang
 rvm:
-  - 2.0.0
-  - 2.1.9
-  - 2.2.6
-  - 2.3.3
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
 before_install:
   - "echo 'gem: --no-ri --no-rdoc --no-document' > ~/.gemrc"
   - "gem install bundler -v 1.13.0"

data/README.md

@@ -5,9 +5,8 @@
 [![Dependency Status](https://gemnasium.com/skateman/surro-gate.svg)](https://gemnasium.com/skateman/surro-gate)
 [![Inline docs](http://inch-ci.org/github/skateman/surro-gate.svg?branch=master)](http://inch-ci.org/github/skateman/surro-gate)
 [![Code Climate](https://codeclimate.com/github/skateman/surro-gate/badges/gpa.svg)](https://codeclimate.com/github/skateman/surro-gate)
-[![codecov](https://codecov.io/gh/skateman/surro-gate/branch/master/graph/badge.svg)](https://codecov.io/gh/skateman/surro-gate)
 
-SurroGate is a general purpose TCP-to-TCP proxy implemented in Ruby.
+SurroGate is a generic purrpose TCP-to-TCP proxy for Ruby implemented using epoll.
 
 ## Installation
 
@@ -32,15 +31,27 @@ require 'surro-gate'
 
 proxy = SurroGate.new
 
-# Create two TCP socket connections
-left = TCPSocket.new('localhost', 3333)
-right = TCPSocket.new('localhost', 2222)
-
-# Push the sockets to the proxy
-proxy.push(left, right)
-
-# Wait for the communication to finish
-proxy.wait
+# Create a pair of TCP socket connections
+sock_1 = TCPSocket.new('localhost', 1111)
+sock_2 = TCPSocket.new('localhost', 2222)
+
+# Push the pair of sockets to the proxy
+proxy.push(sock_1, sock_2)
+
+loop do
+  # Select with a 1 second timeout
+  proxy.select(1000)
+
+  # Do some hard work
+  proxy.each_ready do |left, right|
+    begin
+      right.write_nonblock(left.read_nonblock(4096))
+    rescue => ex
+      # ...
+      proxy.pop(left, right) # Remove the failed connection pair from the proxy
+    end
+  end
+end
 
 ```
 

data/Rakefile

@@ -1,6 +1,16 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'rake/extensiontask'
+require 'surro-gate/version'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+Rake::ExtensionTask.new('surro-gate') do |ext|
+  ext.name = 'surro-gate/selector_ext'
+end
+
+task :default => SurroGate::HAVE_EXT ? %i[compile spec] : %i[clean spec]
+
+CLEAN.include '**/*.o', '**/*.so', 'pkg', 'tmp'

data/ext/surro-gate/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_header 'sys/epoll.h'
+create_makefile 'surro-gate/selector_ext'

data/ext/surro-gate/selector_ext.c

@@ -0,0 +1,203 @@
+#include "selector_ext.h"
+
+static VALUE mSurroGate = Qnil;
+static VALUE cSurroGate_Selector = Qnil;
+static VALUE cSurroGate_Pair = Qnil;
+
+void epoll_register(int *epoll, int socket, int ltr, int rtl) {
+  struct epoll_event ev;
+  ev.data.u64 = ((uint64_t)ltr) << 32 | rtl;
+  ev.events = EPOLLONESHOT | EPOLLIN | EPOLLOUT;
+  epoll_ctl(*epoll, EPOLL_CTL_ADD, socket, &ev);
+}
+
+void epoll_deregister(int *epoll, int socket) {
+  epoll_ctl(*epoll, EPOLL_CTL_DEL, socket, NULL);
+}
+
+void epoll_rearm(int *epoll, int socket, int ltr, int rtl, int events) {
+  struct epoll_event ev;
+  ev.data.u64 = ((uint64_t)ltr) << 32 | rtl;
+  ev.events = EPOLLONESHOT | events;
+  epoll_ctl(*epoll, EPOLL_CTL_MOD, socket, &ev);
+}
+
+static VALUE pairing_compare(VALUE pair, VALUE sockets) {
+  int i;
+  VALUE left = rb_iv_get(pair, "@left");
+  VALUE right = rb_iv_get(pair, "@right");
+
+  for (i=0; i<RARRAY_LEN(sockets); i++) { // sockets.each
+    VALUE item = rb_ary_entry(sockets, i);
+    if (left == item || right == item) {
+      return Qtrue;
+    }
+  }
+
+  return Qnil;
+};
+
+static VALUE pairing_iterate(VALUE pair, VALUE self, int argc, VALUE *argv) {
+  int *selector;
+  VALUE inverse, inv_idx;
+
+  // Yield only for the pairs that are ready
+  if (rb_funcall(pair, rb_intern("ready?"), 0) == Qtrue) {
+    rb_yield_values(2, rb_iv_get(pair, "@left"), rb_iv_get(pair, "@right")); // yield(pair.left, pair.right)
+
+    inv_idx = rb_iv_get(pair, "@inverse");
+    inverse = rb_funcall(rb_iv_get(self, "@pairing"), rb_intern("[]"), 1, inv_idx); // @pairing[inv_idx]
+
+    rb_iv_set(pair, "@rd_rdy", Qfalse);
+    rb_iv_set(pair, "@wr_rdy", Qfalse);
+
+    Data_Get_Struct(self, int, selector);
+    // Rearm left socket for reading and also writing if not ready for writing
+    epoll_rearm(selector, SOCK_PTR(rb_iv_get(pair, "@left")), NUM2INT(argv[1]), NUM2INT(inv_idx), EPOLLIN | (IVAR_TRUE(inverse, "@wr_rdy") ? 0 : EPOLLOUT));
+    // Rearm right socket for writing and also reading if not ready for reading
+    epoll_rearm(selector, SOCK_PTR(rb_iv_get(pair, "@right")), NUM2INT(inv_idx), NUM2INT(argv[1]), EPOLLOUT | (IVAR_TRUE(inverse, "@rd_rdy") ? 0 : EPOLLIN));
+  }
+  return Qnil;
+}
+
+static VALUE SurroGate_Selector_allocate(VALUE self) {
+  int *selector = malloc(sizeof(int));
+
+  if (selector != NULL) {
+    *selector = epoll_create1(0);
+    if (*selector > 0) {
+      return Data_Wrap_Struct(self, NULL, SurroGate_Selector_free, selector);
+    } else {
+      xfree(selector);
+    }
+  }
+
+  rb_raise(rb_eRuntimeError, "Allocation failed!");
+  return Qnil;
+}
+
+static void SurroGate_Selector_free(int *selector) {
+  close(*selector);
+  xfree(selector);
+}
+
+static VALUE SurroGate_Selector_initialize(VALUE self, VALUE logger) {
+  VALUE mConcurrent = rb_const_get(rb_cObject, rb_intern("Concurrent"));
+  VALUE cArray = rb_const_get(mConcurrent, rb_intern("Array"));
+
+  rb_iv_set(self, "@pairing", rb_class_new_instance(0, NULL, cArray)); // @pairing = Concurrent::Array.new
+  rb_iv_set(self, "@logger", logger);
+
+  return Qnil;
+}
+
+static VALUE SurroGate_Selector_push(VALUE self, VALUE left, VALUE right) {
+  int index_ltr, index_rtl, *selector;
+
+  VALUE pair_LTR[2] = {left, right};
+  VALUE pair_RTL[2] = {right, left};
+  VALUE left_to_right = rb_class_new_instance(2, pair_RTL, cSurroGate_Pair); // SurroGate::Pair.new(left, right)
+  VALUE right_to_left = rb_class_new_instance(2, pair_LTR, cSurroGate_Pair); // SurroGate::Pair.new(right, left)
+
+  VALUE pairing = rb_iv_get(self, "@pairing");
+
+  Check_Type(left, T_FILE);
+  Check_Type(right, T_FILE);
+
+  // raise ArgumentError if @pairing.detect(&pairing_compare)
+  if (rb_block_call(pairing, rb_intern("detect"), 0, NULL, pairing_compare, rb_ary_new_from_values(2, pair_LTR)) != Qnil) {
+    rb_raise(rb_eArgError, "Socket already registered!");
+  }
+
+  Data_Get_Struct(self, int, selector);
+
+  rb_funcall(pairing, rb_intern("push"), 2, left_to_right, right_to_left); // @pairing.push(left_to_right, right_to_left)
+  index_ltr = NUM2INT(rb_funcall(pairing, rb_intern("index"), 1, left_to_right)); // @pairing.index(left_to_right)
+  index_rtl = NUM2INT(rb_funcall(pairing, rb_intern("index"), 1, right_to_left)); // @pairing.index(right_to_left)
+
+  rb_iv_set(left_to_right, "@inverse", INT2NUM(index_rtl));
+  rb_iv_set(right_to_left, "@inverse", INT2NUM(index_ltr));
+
+  epoll_register(selector, SOCK_PTR(left), index_ltr, index_rtl);
+  epoll_register(selector, SOCK_PTR(right), index_rtl, index_ltr);
+
+  return Qtrue;
+}
+
+static VALUE SurroGate_Selector_pop(VALUE self, VALUE sockets) {
+  int i, *selector;
+
+  VALUE pairing = rb_iv_get(self, "@pairing");
+  rb_block_call(pairing, rb_intern("delete_if"), 0, NULL, pairing_compare, sockets); // @pairing.delete_if(&pairing_compare)
+
+  Data_Get_Struct(self, int, selector);
+  for (i=0; i<RARRAY_LEN(sockets); i++) {
+    epoll_deregister(selector, SOCK_PTR(rb_ary_entry(sockets, i)));
+  }
+
+  return Qnil;
+}
+
+static VALUE SurroGate_Selector_select(VALUE self, VALUE timeout) {
+  int i, count, *selector, source, target;
+  struct epoll_event events[256];
+  VALUE read, write, socket;
+
+  VALUE pairing = rb_iv_get(self, "@pairing");
+  Data_Get_Struct(self, int, selector);
+
+  count = epoll_wait(*selector, events, 256, NUM2INT(timeout));
+
+  for (i=0; i<count; i++) {
+    source = (int)((events[i].data.u64 & 0xFFFFFFFF00000000LL) >> 32);
+    target = (int)(events[i].data.u64 & 0xFFFFFFFFLL);
+
+    read = rb_funcall(pairing, rb_intern("[]"), 1, INT2NUM(target)); // @pairing[source]
+    write = rb_funcall(pairing, rb_intern("[]"), 1, INT2NUM(source)); // @pairing[target]
+
+    if (events[i].events & EPOLLIN && events[i].events & EPOLLOUT) {
+      // Socket is both available for read and write
+      rb_iv_set(read, "@rd_rdy", Qtrue); // read.rd_rdy = true
+      rb_iv_set(write, "@wr_rdy", Qtrue); // write.wr_rdy = true
+    } else if (events[i].events & EPOLLIN) {
+      // Socket is available for read, reregister it for write if not writable
+      rb_iv_set(read, "@rd_rdy", Qtrue); // read.rd_rdy = true
+      if (rb_iv_get(write, "@wr_rdy") == Qfalse) { // if !write.wr_rdy
+        socket = rb_iv_get(read, "@left"); // read.left
+        epoll_rearm(selector, SOCK_PTR(socket), target, source, EPOLLOUT);
+      }
+    } else if (events[i].events & EPOLLOUT) {
+      // Socket is available for write, reregister it for read if not readable
+      rb_iv_set(write, "@wr_rdy", Qtrue); // write.wr_rdy = true
+      if (rb_iv_get(write, "@rd_rdy") == Qfalse) { // if !source.rd_rdy
+        socket = rb_iv_get(write, "@right"); // write.right
+        epoll_rearm(selector, SOCK_PTR(socket), source, target, EPOLLIN);
+      }
+    }
+  }
+
+  return INT2NUM(count);
+}
+
+static VALUE SurroGate_Selector_each_ready(VALUE self) {
+  VALUE pairing = rb_iv_get(self, "@pairing");
+  rb_need_block();
+  return rb_block_call(pairing, rb_intern("each_with_index"), 0, NULL, pairing_iterate, self);
+}
+
+void Init_selector_ext() {
+  rb_require("concurrent");
+  rb_require("surro-gate/pair");
+
+  mSurroGate = rb_define_module("SurroGate");
+  cSurroGate_Selector = rb_define_class_under(mSurroGate, "Selector", rb_cObject);
+  cSurroGate_Pair = rb_const_get(mSurroGate, rb_intern("Pair"));
+
+  rb_define_alloc_func(cSurroGate_Selector, SurroGate_Selector_allocate);
+
+  rb_define_method(cSurroGate_Selector, "initialize", SurroGate_Selector_initialize, 1);
+  rb_define_method(cSurroGate_Selector, "push", SurroGate_Selector_push, 2);
+  rb_define_method(cSurroGate_Selector, "pop", SurroGate_Selector_pop, -2);
+  rb_define_method(cSurroGate_Selector, "select", SurroGate_Selector_select, 1);
+  rb_define_method(cSurroGate_Selector, "each_ready", SurroGate_Selector_each_ready, 0);
+}

data/ext/surro-gate/selector_ext.h

@@ -0,0 +1,22 @@
+#ifndef SELECTOR_EXT_H
+#define SELECTOR_EXT_H
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include "stdlib.h"
+#include "sys/epoll.h"
+
+#define SOCK_PTR(X) RFILE(X)->fptr->fd
+#define IVAR_TRUE(X, Y) rb_iv_get(X, Y) == Qtrue
+
+static VALUE SurroGate_Selector_allocate(VALUE self);
+static VALUE SurroGate_Selector_initialize(VALUE self, VALUE logger);
+static VALUE SurroGate_Selector_push(VALUE self, VALUE left, VALUE right);
+static VALUE SurroGate_Selector_select(VALUE self, VALUE timeout);
+static VALUE SurroGate_Selector_each_ready(VALUE self);
+
+static void SurroGate_Selector_free(int *epoll);
+static VALUE pairing_compare(VALUE pair, VALUE sockets);
+static VALUE pairing_iterate(VALUE pair, VALUE self, int argc, VALUE *argv);
+
+#endif

data/lib/surro-gate/pair.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SurroGate
+  class Pair
+    attr_reader :left, :right
+
+    def initialize(left, right)
+      @left = left
+      @right = right
+      @rd_rdy = @wr_rdy = false
+    end
+
+    def ready?
+      @rd_rdy && @wr_rdy || @left.closed? || @right.closed?
+    end
+  end
+end

data/lib/surro-gate/selector.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'surro-gate/pair'
+require 'concurrent'
+
+module SurroGate
+  class Selector
+    def initialize(logger)
+      @logger = logger
+
+      @pairing = Concurrent::Array.new
+      @sockets = Concurrent::Array.new
+      @reads = Concurrent::Array.new
+      @writes = Concurrent::Array.new
+
+      @mutex = Mutex.new
+    end
+
+    def push(left, right)
+      raise TypeError unless left.is_a?(IO) && right.is_a?(IO)
+      raise ArgumentError if @pairing.detect { |pair| [left, right].include?(pair.left) || [left, right].include?(pair.right) }
+
+      left_to_right = SurroGate::Pair.new(left, right)
+      right_to_left = SurroGate::Pair.new(right, left)
+
+      # The method can be called from a different thread
+      @mutex.synchronize do
+        @pairing.push(left_to_right, right_to_left)
+
+        @sockets.push(left, right)
+        @reads.push(left, right)
+        @writes.push(left, right)
+      end
+
+      true
+    end
+
+    def pop(*sockets)
+      [@sockets, @reads, @writes].each do |arr|
+        arr.delete_if { |sock| sockets.include?(sock) }
+      end
+
+      @pairing.delete_if { |pair| pairing_compare(pair, sockets) }
+
+      nil
+    end
+
+    def select(timeout)
+      begin
+        read, write, error = @mutex.synchronize { IO.select(@reads, @writes, @sockets, timeout * 0.001) }
+      rescue IOError
+        # One of the sockets is closed, Pair#ready? will catch it
+      end
+
+      error.to_a.each do
+        ltr = find_pairing(sock, :left)
+        rtl = find_pairing(sock, :right)
+
+        [ltr, rtl].each do |pair|
+          %i[@rd_rdy @wr_rdy].each do |ivar|
+            pair.instance_variable_set(ivar, true)
+          end
+        end
+      end
+
+      read.to_a.each do |sock|
+        @reads.delete(sock)
+        find_pairing(sock, :left).instance_variable_set(:@rd_rdy, true)
+      end
+
+      write.to_a.each do |sock|
+        @writes.delete(sock)
+        find_pairing(sock, :right).instance_variable_set(:@wr_rdy, true)
+      end
+
+      read.to_a.length + write.to_a.length
+    end
+
+    def each_ready
+      @pairing.each do |pair|
+        next unless pair.ready?
+
+        yield(pair.left, pair.right)
+
+        pair.instance_variable_set(:@rd_rdy, false)
+        pair.instance_variable_set(:@wr_rdy, false)
+
+        @reads.push(pair.left)
+        @writes.push(pair.right)
+      end
+    end
+
+    private
+
+    def find_pairing(sock, direction)
+      @pairing.find { |pair| pair.send(direction) == sock }
+    end
+
+    def pairing_compare(pair, sockets)
+      sockets.each do |sock|
+        return true if [pair.left, pair.right].include?(sock)
+      end
+    end
+  end
+end

data/lib/surro-gate/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
 module SurroGate
-  VERSION = '0.2.2'.freeze
+  VERSION = '1.0.0'.freeze
+  HAVE_EXT = RUBY_PLATFORM =~ /linux/ && !defined?(JRUBY_VERSION) && !ENV['SURRO_GATE_NOEXT']
 end

data/lib/surro-gate.rb

@@ -1,14 +1,20 @@
+# frozen_string_literal: true
+
 require 'surro-gate/version'
-require 'surro-gate/proxy_error'
-require 'surro-gate/proxy'
 
-# A generic purpose TCP-to-TCP proxy
+begin
+  require 'surro-gate/selector_ext'
+rescue LoadError, NameError # Fall back to IO#select if epoll isn't available
+  require 'surro-gate/selector'
+end
+
+# A generic purrpose TCP-to-TCP proxy selector
 module SurroGate
   class << self
-    # Initializes a new Proxy instance
-    # @return [Proxy]
+    # Initializes a new Selector instance
+    # @return [SurroGate::Selector]
     def new(logger = nil)
-      Proxy.new(logger)
+      SurroGate::Selector.new(logger)
     end
   end
 end

data/surro-gate.gemspec

@@ -1,5 +1,6 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'surro-gate/version'
 
@@ -9,24 +10,23 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Dávid Halász']
   spec.email         = ['skateman@skateman.eu']
 
-  spec.summary       = 'A general purrpose TCP-to-TCP proxy written in Ruby'
-  spec.description   = 'A general purrpose TCP-to-TCP proxy written in Ruby'
+  spec.summary       = 'A generic purrpose TCP-to-TCP proxy in Ruby'
+  spec.description   = 'A generic purrpose TCP-to-TCP proxy for Ruby implemented using epoll'
   spec.homepage      = 'https://github.com/skateman/surro-gate'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
+  spec.extensions    = ['ext/surro-gate/extconf.rb'] if SurroGate::HAVE_EXT
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'nio4r', '~> 1.2.0'
+  spec.add_dependency 'concurrent-ruby'
 
-  spec.add_development_dependency 'bundler', '~> 1.13'
-  spec.add_development_dependency 'codecov', '~> 0.1.0'
-  spec.add_development_dependency 'nyan-cat-formatter', '~> 0.11'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'simplecov', '~> 0.12'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rake-compiler'
+  spec.add_development_dependency 'rspec'
 end

metadata

@@ -1,118 +1,91 @@
 --- !ruby/object:Gem::Specification
 name: surro-gate
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Dávid Halász
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-12 00:00:00.000000000 Z
+date: 2018-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nio4r
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.13'
-- !ruby/object:Gem::Dependency
-  name: codecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-- !ruby/object:Gem::Dependency
-  name: nyan-cat-formatter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.11'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
-description: A general purrpose TCP-to-TCP proxy written in Ruby
+        version: '0'
+description: A generic purrpose TCP-to-TCP proxy for Ruby implemented using epoll
 email:
 - skateman@skateman.eu
 executables: []
-extensions: []
+extensions:
+- ext/surro-gate/extconf.rb
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
@@ -128,9 +101,12 @@ files:
 - bin/console
 - bin/setup
 - codecov.yml
+- ext/surro-gate/extconf.rb
+- ext/surro-gate/selector_ext.c
+- ext/surro-gate/selector_ext.h
 - lib/surro-gate.rb
-- lib/surro-gate/proxy.rb
-- lib/surro-gate/proxy_error.rb
+- lib/surro-gate/pair.rb
+- lib/surro-gate/selector.rb
 - lib/surro-gate/version.rb
 - surro-gate.gemspec
 homepage: https://github.com/skateman/surro-gate
@@ -153,8 +129,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
-summary: A general purrpose TCP-to-TCP proxy written in Ruby
+summary: A generic purrpose TCP-to-TCP proxy in Ruby
 test_files: []

data/lib/surro-gate/proxy.rb

@@ -1,129 +0,0 @@
-require 'nio'
-require 'logger'
-
-module SurroGate
-  # This class is responsible for connecting TCP socket pairs and proxying between them.
-  #
-  # It uses a lazily-forked thread to handle the non blocking read and write operations.
-  # If one of the sockets get closed, the proxy automatically cleans up by deregistering
-  # and closing its pair. When the last socket pair gets cleaned up, the internal thread
-  # is killed automatically.
-  #
-  # The proxy was designed to be highly reusable and it can handle multiple socket pairs.
-  class Proxy
-    def initialize(logger)
-      @mutex = Mutex.new
-      @reader = NIO::Selector.new
-      @writer = NIO::Selector.new
-      @selectors = [@reader, @writer]
-      @log = logger || Logger.new(STDOUT)
-    end
-
-    # Registers a pair of socket for proxying.
-    #
-    # It also forks the internal thread if it is not running yet.
-    #
-    # @raise [ProxyError] when at least one of the pushed sockets is already registered
-    # @param left [TCPSocket]
-    # @param right [TCPSocket]
-    # @yield The block responsible for additional cleanup
-    # @return the registered socket pair as an array
-    def push(left, right, &block)
-      raise ProxyError, 'Socket already handled by the proxy' if includes?(left, right)
-
-      @log.info("Connecting #{left} <-> #{right}")
-
-      @mutex.synchronize do
-        proxy(left, right, block)
-      end
-
-      [left, right]
-    end
-
-    # Blocking wait until the internal thread is doing something useful.
-    def wait
-      @thread.join if alive?
-    end
-
-    # Determine if the internal thread is currently running or not.
-    def alive?
-      !@thread.nil? && @thread.alive?
-    end
-
-    private
-
-    def proxy(left, right, block = nil)
-      # Register the proxying in both directions
-      [[left, right], [right, left]].each do |rd, wr|
-        # Set up monitors for read/write separately
-        src = @reader.register(rd, :r)
-        dst = @writer.register(wr, :w)
-
-        # Set up handlers for the reader monitor
-        src.value = proc do
-          # Clean up the connection if one of the endpoints gets closed
-          cleanup(src.io, dst.io, &block) if src.io.closed? || dst.io.closed?
-          # Do the transmission and return with the bytes transferred
-          transmit(src.io, dst.io, block) if src.readable? && dst.writable?
-        end
-      end
-
-      thread_start unless @reader.empty? || @writer.empty?
-    end
-
-    def transmit(src, dst, block)
-      dst.write_nonblock(src.read_nonblock(4096))
-    rescue # Clean up both sockets if something bad happens
-      @log.warn("Transmission failure between #{src} <-> #{dst}")
-      cleanup(src, dst, &block)
-    end
-
-    def cleanup(*sockets)
-      # Deregister and close the sockets
-      sockets.each do |socket|
-        @selectors.each { |selector| selector.deregister(socket) if selector.registered?(socket) }
-        socket.close unless socket.closed?
-      end
-
-      @log.info("Disconnecting #{sockets.join(' <-> ')}")
-
-      yield if block_given?
-
-      # Make sure that the internal thread is stopped if no sockets remain
-      thread_stop if @reader.empty? && @writer.empty?
-    end
-
-    def thread_start
-      @log.debug('Starting the internal thread')
-      @thread ||= Thread.new do
-        loop do
-          reactor
-        end
-      end
-    end
-
-    def thread_stop
-      return if @thread.nil?
-      @log.debug('Stopping the internal thread')
-      thread = @thread
-      @thread = nil
-      thread.kill
-    end
-
-    def reactor
-      # Atomically get an array of readable monitors while also polling for writables
-      monitors = @mutex.synchronize do
-        @writer.select(0.1)
-        @reader.select(0.1) || []
-      end
-      # Call each transmission proc and collect the results
-      monitors.map { |m| m.value.call }
-    end
-
-    def includes?(*sockets)
-      sockets.any? do |socket|
-        @selectors.any? { |selector| selector.registered?(socket) }
-      end
-    end
-  end
-end

data/lib/surro-gate/proxy_error.rb

@@ -1,5 +0,0 @@
-module SurroGate
-  # This error is raised when at least one of the pushed sockets is already registered
-  class ProxyError < StandardError
-  end
-end