cool.io 1.10.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9494578f6a02a987a84805bca37919a7c0e63c4c585a7bdf8c68e18e38d21e8d
-  data.tar.gz: 0cae209afee54a8f6f59014afb71ee2357dabdc350cfc60dfe2a6212062dbf1e
+  metadata.gz: 84ec70f3ced722b0919a7e3348a6670e9d474343f8b831d9e942222a1edd0314
+  data.tar.gz: b60d4526c1c799119c43db2ae0e0f3debb85cba85086a6c65868477398a88a66
 SHA512:
-  metadata.gz: ccb23719b38180b44cd6485901a35a15710daf77f4079a7fbdbc1d77fcfe86b75787d82c8cd8f455f5199a7f390125d6d62320eeff2785b2193c6fe5612c7653
-  data.tar.gz: 2ab5356bc8ab69fb93c6f3c6532ada9c67b63c774e7a952f20526b1bf3660fde681a3b480130deaf436212b4b0d77b51859fefcb9d4f0a6dc983b0a46de70f2c
+  metadata.gz: 924f47393f2ae881e1afb914fa16bb67089840e8ef1c3599502919c5fa53263c06e0f6303d263ae376d8bff33da00ad9577b6549e3fc5128ead104a4f383e9d2
+  data.tar.gz: 8929ec98ce4161507309610d762c5f22f7fe4b756c361902fb0e37afa69ee2d8adc788383866ec7c9d270b80f27a99e902c2ef5128804e3b9e86c2b46c6e0535

data/ext/cool.io/ev_wrap.h

@@ -1,10 +1,17 @@
 #define EV_STANDALONE              /* keeps ev from requiring config.h */
 
 #ifdef _WIN32
+#include "ruby.h"
 #define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
 #define EV_USE_MONOTONIC 0
 #define EV_USE_REALTIME 0
 #define EV_WIN32_STAT_CODEPAGE CP_UTF8 /* Ruby paths are UTF-8. */
+/* Close the evpipe sockets with closesocket() through Ruby. The CRT close()
+ * only calls CloseHandle(), which leaves Winsock state behind. A socket later
+ * imported from a WSAPROTOCOL_INFO with the same handle value inherits it, and
+ * listen() fails with WSAEISCONN. */
+#define EV_WIN32_HANDLE_TO_FD(handle) rb_w32_wrap_io_handle((HANDLE)(handle), 0)
+#define EV_WIN32_CLOSE_FD(fd) rb_w32_close(fd)
 #endif
 
 #include "../libev/ev.h"

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.10.0"
+  VERSION = "1.10.1"
 
   def self.version
     VERSION

data/spec/fixtures/windows_stat_native.c

@@ -1284,6 +1284,76 @@ alias_recovery (VALUE self, VALUE path)
     retried ? Qtrue : Qfalse, cached ? Qtrue : Qfalse);
 }
 
+static VALUE
+imported_listen_failures (VALUE self, VALUE tries)
+{
+  enum { limit = 64 };
+  WSADATA data;
+  WSAPROTOCOL_INFOW info;
+  struct sockaddr_in addr;
+  SOCKET sockets[limit * 2], base, imported;
+  const char *failure = 0;
+  int i, error = 0, opened = 0, failures = 0, count = NUM2INT (tries);
+  if (count < 0 || count > limit)
+    {
+      rb_raise (rb_eArgError, "tries must be between 0 and %d", limit);
+    }
+  if (WSAStartup (MAKEWORD (2, 2), &data))
+    {
+      rb_raise (rb_eRuntimeError, "WSAStartup failed");
+    }
+  memset (&addr, 0, sizeof (addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  for (i = 0; i < count; ++i)
+    {
+      base = WSASocketW (AF_INET, SOCK_STREAM, IPPROTO_TCP, 0, 0, WSA_FLAG_OVERLAPPED);
+      if (base == INVALID_SOCKET)
+        {
+          failure = "WSASocketW failed";
+          error = WSAGetLastError ();
+          break;
+        }
+      sockets[opened++] = base;
+      if (bind (base, (struct sockaddr *)&addr, sizeof (addr))
+          || WSADuplicateSocketW (base, GetCurrentProcessId (), &info))
+        {
+          failure = "could not prepare a socket to import";
+          error = WSAGetLastError ();
+          break;
+        }
+      imported = WSASocketW (FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
+                             &info, 0, WSA_FLAG_OVERLAPPED);
+      if (imported == INVALID_SOCKET)
+        {
+          failure = "WSASocketW could not import the socket";
+          error = WSAGetLastError ();
+          break;
+        }
+      sockets[opened++] = imported;
+      if (listen (imported, 1) == SOCKET_ERROR)
+        {
+          error = WSAGetLastError ();
+          if (error != WSAEISCONN)
+            {
+              failure = "listen failed";
+              break;
+            }
+          ++failures;
+        }
+    }
+  while (opened)
+    {
+      closesocket (sockets[--opened]);
+    }
+  WSACleanup ();
+  if (failure)
+    {
+      rb_raise (rb_eRuntimeError, "%s: %d", failure, error);
+    }
+  return INT2NUM (failures);
+}
+
 RUBY_FUNC_EXPORTED void
 Init_coolio_stat_native (void)
 {
@@ -1302,4 +1372,5 @@ Init_coolio_stat_native (void)
   rb_define_singleton_method (module, "children_cwd", children_cwd, 3);
   rb_define_singleton_method (module, "replaced_dir", replaced_dir, 2);
   rb_define_singleton_method (module, "alias_recovery", alias_recovery, 1);
+  rb_define_singleton_method (module, "imported_listen_failures", imported_listen_failures, 1);
 }

data/spec/windows_stat_native_spec.rb

@@ -177,6 +177,25 @@ describe 'Windows stat notification internals', :if => RUBY_PLATFORM =~ /mingw|m
     expect(result).to eq([true, true, true, true])
   end
 
+  it 'closes the notification pipe of a destroyed loop so that imported sockets can listen' do
+    lib = File.expand_path('../lib', __dir__)
+    result = native_result(<<~'RUBY', lib, @build)
+      $LOAD_PATH.unshift(ARGV[0])
+      require 'cool.io'
+      path = File.join(ARGV[1], 'evpipe.txt')
+      File.write(path, 'a')
+      20.times do
+        reactor = Coolio::Loop.new
+        watcher = Coolio::StatWatcher.new(path, 60)
+        watcher.attach(reactor)
+        watcher.detach
+      end
+      3.times { GC.start }
+      $stdout.write(Marshal.dump(CoolioStatNativeSpec.imported_listen_failures(30)))
+    RUBY
+    expect(result).to eq(0)
+  end
+
   it 'uses effective notification flags and respects EVFLAG_NOENV' do
     path = File.join(@build, 'flags.txt')
     # EVFLAG_NOINOTIFY = 0x00100000; EVFLAG_NOENV = 0x01000000.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.10.1
 platform: ruby
 authors:
 - Tony Arcieri