polyphony 0.13 → 0.14

data/ext/libev/test_libev_win32.c

@@ -0,0 +1,123 @@
+  // a single header file is required
+  #include <ev.h>
+   #include <stdio.h>
+   #include <io.h>
+
+   // every watcher type has its own typedef'd struct
+   // with the name ev_TYPE
+   ev_io stdin_watcher;
+   ev_timer timeout_watcher;
+
+   // all watcher callbacks have a similar signature
+   // this callback is called when data is readable on stdin
+   static void
+   stdin_cb (EV_P_ ev_io *w, int revents)
+   {
+     puts ("stdin ready or done or something");
+     // for one-shot events, one must manually stop the watcher
+     // with its corresponding stop function.
+     //ev_io_stop (EV_A_ w);
+
+     // this causes all nested ev_loop's to stop iterating
+     //ev_unloop (EV_A_ EVUNLOOP_ALL);
+   }
+
+   // another callback, this time for a time-out
+   static void
+   timeout_cb (EV_P_ ev_timer *w, int revents)
+   {
+     puts ("timeout");
+     // this causes the innermost ev_loop to stop iterating
+     ev_unloop (EV_A_ EVUNLOOP_ONE);
+   }
+
+
+
+   #include <winsock.h>
+
+#include <stdlib.h>
+#include <iostream>
+   int get_server_fd()
+   {
+
+  //----------------------
+  // Initialize Winsock.
+  WSADATA wsaData;
+  int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+  if (iResult != NO_ERROR) {
+    printf("Error at WSAStartup()\n");
+    return 1;
+  }
+
+  //----------------------
+  // Create a SOCKET for listening for
+  // incoming connection requests.
+  SOCKET ListenSocket;
+  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (ListenSocket == INVALID_SOCKET) {
+    printf("Error at socket(): %ld\n", WSAGetLastError());
+    WSACleanup();
+    return 1;
+  }
+  printf("socket returned %d\n", ListenSocket);
+
+  //----------------------
+  // The sockaddr_in structure specifies the address family,
+  // IP address, and port for the socket that is being bound.
+  sockaddr_in service;
+  service.sin_family = AF_INET;
+  service.sin_addr.s_addr = inet_addr("127.0.0.1");
+  service.sin_port = htons(4444);
+
+  if (bind( ListenSocket,
+    (SOCKADDR*) &service,
+    sizeof(service)) == SOCKET_ERROR) {
+    printf("bind() failed.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+  //----------------------
+  // Listen for incoming connection requests.
+  // on the created socket
+  if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
+    printf("Error listening on socket.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+
+  printf("sock and osf handle are %d %d, error is \n", ListenSocket, _get_osfhandle (ListenSocket)); // -1 is invalid file handle: http://msdn.microsoft.com/en-us/library/ks2530z6.aspx
+  printf("err was %d\n",  WSAGetLastError());
+  //----------------------
+  return ListenSocket;
+   }
+
+
+   int
+   main (void)
+   {
+     struct ev_loop *loopy = ev_default_loop(0);
+     int fd = get_server_fd();
+     int fd_real =  _open_osfhandle(fd, NULL);
+     int conv = _get_osfhandle(fd_real);
+     printf("got server fd %d, loop %d, fd_real %d, that converted %d\n", fd, loopy, fd_real, conv);
+    // accept(fd, NULL, NULL);
+     // initialise an io watcher, then start it
+     // this one will watch for stdin to become readable
+     ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ conv, EV_READ);
+     ev_io_start (loopy, &stdin_watcher);
+
+     // initialise a timer watcher, then start it
+     // simple non-repeating 5.5 second timeout
+     //ev_timer_init (&timeout_watcher, timeout_cb, 15.5, 0.);
+     //ev_timer_start (loopy, &timeout_watcher);
+    printf("starting loop\n");
+     // now wait for events to arrive
+     ev_loop (loopy, 0);
+
+     // unloop was called, so exit
+     return 0;
+   }

data/lib/polyphony.rb

@@ -7,19 +7,24 @@ export_default :Polyphony
 Polyphony = import('./polyphony/core')
 Exceptions = import('./polyphony/core/exceptions')
 
+import('polyphony/extensions/socket')
+import('polyphony/extensions/ssl')
+
 module Polyphony
   Cancel        = Exceptions::Cancel
   MoveOn        = Exceptions::MoveOn
 
+  Net = import('./polyphony/net')
+
   auto_import(
     Channel:      './polyphony/core/channel',
-    Coroutine:    './polyphony/core/coroutine',
+    Coprocess:    './polyphony/core/coprocess',
     Sync:         './polyphony/core/sync',
     Thread:       './polyphony/core/thread',
     ThreadPool:   './polyphony/core/thread_pool',
   
     FS:           './polyphony/fs',
-    Net:          './polyphony/net',
+    # Net:          './polyphony/net',
     ResourcePool: './polyphony/resource_pool',
     Supervisor:   './polyphony/supervisor'
   )

data/lib/polyphony/core.rb

@@ -22,7 +22,7 @@ module Core
     pid = Kernel.fork do
       FiberPool.reset!
       EV.post_fork
-      Fiber.current.coroutine = Coroutine.new(Fiber.current)
+      Fiber.current.coprocess = Coprocess.new(Fiber.current)
 
       block.()
 

data/lib/polyphony/core/{coroutine.rb → coprocess.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-export_default :Coroutine
+export_default :Coprocess
 
 import('../extensions/kernel')
 
@@ -8,7 +8,7 @@ FiberPool   = import('./fiber_pool')
 Exceptions  = import('./exceptions')
 
 # Encapsulates an asynchronous task
-class Coroutine
+class Coprocess
   attr_reader :result, :fiber
 
 
@@ -21,7 +21,7 @@ class Coroutine
     @caller = caller if Exceptions.debug
 
     @fiber = FiberPool.spawn do
-      @fiber.coroutine = self
+      @fiber.coprocess = self
       @result = (@block || block2).call(self)
     rescue Exceptions::MoveOn, Exceptions::Stop => e
       @result = e.value
@@ -29,7 +29,7 @@ class Coroutine
       e.cleanup_backtrace(@caller) if Exceptions.debug
       @result = e
     ensure
-      @fiber.coroutine = nil
+      @fiber.coprocess = nil
       @fiber = nil
       @awaiting_fiber&.schedule @result
       @when_done&.()
@@ -66,7 +66,7 @@ class Coroutine
   end
 
   # Kernel.await expects the given argument / block to be a callable, so #call
-  # in fact waits for the coroutine to finish
+  # in fact waits for the coprocess to finish
   def await
     run unless @ran
     if @fiber
@@ -76,7 +76,7 @@ class Coroutine
       @result
     end
   ensure
-    # if awaiting was interrupted and the coroutine is still running, we need to stop it
+    # if awaiting was interrupted and the coprocess is still running, we need to stop it
     if @fiber
       @fiber&.schedule(Exceptions::MoveOn.new)
       suspend
@@ -91,16 +91,16 @@ class Coroutine
     @fiber&.schedule(value)
   end
 
-  def interrupt(value = Exceptions::MoveOn.new)
-    @fiber&.schedule(value)
+  def interrupt(value = nil)
+    @fiber&.schedule(Exceptions::MoveOn.new(nil, value))
   end
   alias_method :stop, :interrupt
 
   def cancel!
-    interrupt(Exceptions::Cancel.new)
+    @fiber&.schedule(Exceptions::Cancel.new)
   end
 
   def self.current
-    Fiber.current.coroutine
+    Fiber.current.coprocess
   end
 end

data/lib/polyphony/core/exceptions.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-export :CoroutineInterrupt, :MoveOn, :Stop, :Cancel, :debug, :debug=
+export :CoprocessInterrupt, :MoveOn, :Stop, :Cancel, :debug, :debug=
 
-class CoroutineInterrupt < ::Exception
+class CoprocessInterrupt < ::Exception
   attr_reader :scope, :value
 
   def initialize(scope = nil, value = nil)
@@ -11,9 +11,9 @@ class CoroutineInterrupt < ::Exception
   end
 end
 
-class Stop < CoroutineInterrupt; end
-class MoveOn < CoroutineInterrupt; end
-class Cancel < CoroutineInterrupt; end
+class Stop < CoprocessInterrupt; end
+class MoveOn < CoprocessInterrupt; end
+class Cancel < CoprocessInterrupt; end
 
 def debug
   @debug

data/lib/polyphony/core/supervisor.rb

@@ -2,12 +2,12 @@
 
 export_default :Supervisor
 
-Coroutine   = import('./coroutine')
+Coprocess   = import('./coprocess')
 Exceptions  = import('./exceptions')
 
 class Supervisor
   def initialize
-    @coroutines = []
+    @coprocesss = []
   end
 
   def await(&block)
@@ -26,31 +26,31 @@ class Supervisor
   end
 
   def spawn(proc = nil, &block)
-    if proc.is_a?(Coroutine)
-      spawn_coroutine(proc)
+    if proc.is_a?(Coprocess)
+      spawn_coprocess(proc)
     else
       spawn_proc(block || proc)
     end
   end
 
-  def spawn_coroutine(proc)
-    @coroutines << proc
+  def spawn_coprocess(proc)
+    @coprocesss << proc
     proc.when_done { task_completed(proc) }
     proc.run unless proc.running?
     proc
   end
 
   def spawn_proc(proc)
-    @coroutines << Object.spawn do |coroutine|
-      proc.call(coroutine)
-      task_completed(coroutine)
+    @coprocesss << Object.spawn do |coprocess|
+      proc.call(coprocess)
+      task_completed(coprocess)
     rescue Exception => e
-      task_completed(coroutine)
+      task_completed(coprocess)
     end
   end
 
   def still_running?
-    !@coroutines.empty?
+    !@coprocesss.empty?
   end
 
   def stop!(result = nil)
@@ -61,15 +61,15 @@ class Supervisor
 
   def stop_all_tasks
     exception = Exceptions::Stop.new
-    @coroutines.each do |c|
+    @coprocesss.each do |c|
       EV.next_tick { c.interrupt(exception) }
     end
   end
 
-  def task_completed(coroutine)
-    return unless @coroutines.include?(coroutine)
+  def task_completed(coprocess)
+    return unless @coprocesss.include?(coprocess)
     
-    @coroutines.delete(coroutine)
-    @supervisor_fiber&.transfer if @coroutines.empty?
+    @coprocesss.delete(coprocess)
+    @supervisor_fiber&.transfer if @coprocesss.empty?
   end
 end

data/lib/polyphony/core/thread.rb

@@ -23,7 +23,7 @@ end
 
 def wait_for_thread(ctx)
   suspend
-rescue Exceptions::CoroutineInterrupt => e
+rescue Exceptions::CoprocessInterrupt => e
   ctx[:fiber] = nil
   ctx[:thread]&.raise(e)
   raise e

data/lib/polyphony/extensions/io.rb

@@ -14,49 +14,50 @@ class ::IO
     @write_watcher&.stop
   end
 
-  NO_EXCEPTION = { exception: false }.freeze
+  # NO_EXCEPTION = { exception: false }.freeze
 
-  def read(max = 8192, outbuf = nil)
-    outbuf ||= (@read_buffer ||= +'')
-    loop do
-      result = read_nonblock(max, outbuf, NO_EXCEPTION)
-      case result
-      when nil            then raise IOError
-      when :wait_readable then read_watcher.await
-      else                return result
-      end
-    end
-  ensure
-    @read_watcher&.stop
-  end
+  # def read(max = 8192, outbuf = nil)
+  #   outbuf ||= (@read_buffer ||= +'')
+  #   loop do
+  #     result = read_nonblock(max, outbuf, NO_EXCEPTION)
+  #     case result
+  #     when nil            then raise IOError
+  #     when :wait_readable then read_watcher.await
+  #     else                return result
+  #     end
+  #   end
+  # ensure
+  #   @read_watcher&.stop
+  # end
 
-  def write(data)
-    loop do
-      result = write_nonblock(data, NO_EXCEPTION)
-      case result
-      when nil            then raise IOError
-      when :wait_writable then write_watcher.await
-      else
-        (result == data.bytesize) ? (return result) : (data = data[result..-1])
-      end
-    end
-  ensure
-    @write_watcher&.stop
-  end
+  # def write(data)
+  #   loop do
+  #     result = write_nonblock(data, NO_EXCEPTION)
+  #     case result
+  #     when nil            then raise IOError
+  #     when :wait_writable then write_watcher.await
+  #     else
+  #       (result == data.bytesize) ? (return result) : (data = data[result..-1])
+  #     end
+  #   end
+  # ensure
+  #   @write_watcher&.stop
+  # end
 
-  def write_list(*list)
-    list.each do |data|
-      loop do
-        result = write_nonblock(data, NO_EXCEPTION)
-        case result
-        when nil            then raise IOError
-        when :wait_writable then write_watcher.await
-        else
-          (result == data.bytesize) ? (break result) : (data = data[result..-1])
-        end
-      end
-    end
-  ensure
-    @write_watcher&.stop
-  end
+  # # write_list is inspired by 
+  # def write_list(*list)
+  #   list.each do |data|
+  #     loop do
+  #       result = write_nonblock(data, NO_EXCEPTION)
+  #       case result
+  #       when nil            then raise IOError
+  #       when :wait_writable then write_watcher.await
+  #       else
+  #         (result == data.bytesize) ? (break result) : (data = data[result..-1])
+  #       end
+  #     end
+  #   end
+  # ensure
+  #   @write_watcher&.stop
+  # end
 end

data/lib/polyphony/extensions/kernel.rb

@@ -3,7 +3,7 @@
 require 'fiber'
 
 CancelScope = import('../core/cancel_scope')
-Coroutine   = import('../core/coroutine')
+Coprocess   = import('../core/coprocess')
 Exceptions  = import('../core/exceptions')
 Supervisor  = import('../core/supervisor')
 Throttler   = import('../core/throttler')
@@ -11,33 +11,18 @@ Throttler   = import('../core/throttler')
 # Fiber extensions
 class ::Fiber
   attr_writer :cancelled
-  attr_accessor :next_job, :coroutine
+  attr_accessor :next_job, :coprocess
 
   def cancelled?
     @cancelled
   end
 
-  def root?
-    @root
-  end
-
   def schedule(value = nil)
     EV.schedule_fiber(self, value)
   end
 
-  def set_root!
-    @root = true
-  end
-
-  def self.root
-    @@root
-  end
-
-  @@root = Fiber.current
-  @@root.set_root!
-
-  # Associate a (pseudo-)coroutine with the main fiber
-  current.coroutine = Coroutine.new(Fiber.current)
+  # Associate a (pseudo-)coprocess with the main fiber
+  current.coprocess = Coprocess.new(current)
 end
 
 class ::Exception
@@ -60,7 +45,7 @@ module ::Kernel
     if sym
       async_decorate(is_a?(Class) ? self : singleton_class, sym)
     else
-      Coroutine.new(&block)
+      Coprocess.new(&block)
     end
   end
 
@@ -72,9 +57,7 @@ module ::Kernel
   def async_decorate(receiver, sym)
     sync_sym = :"sync_#{sym}"
     receiver.alias_method(sync_sym, sym)
-    receiver.define_method(sym) do |*args, &block|
-      Coroutine.new { send(sync_sym, *args, &block) }
-    end
+    receiver.class_eval("def #{sym}(*args, &block); Coprocess.new { send(#{sync_sym.inspect}, *args, &block) }; end")
   end
 
   def cancel_after(duration, &block)
@@ -113,7 +96,7 @@ module ::Kernel
   end
 
   def receive
-    Fiber.current.coroutine.receive
+    Fiber.current.coprocess.receive
   end
 
   alias_method :sync_sleep, :sleep
@@ -125,10 +108,10 @@ module ::Kernel
   end
 
   def spawn(proc = nil, &block)
-    if proc.is_a?(Coroutine)
+    if proc.is_a?(Coprocess)
       proc.run
     else
-      Coroutine.new(&(block || proc)).run
+      Coprocess.new(&(block || proc)).run
     end
   end
 
@@ -136,13 +119,6 @@ module ::Kernel
     Supervisor.new.await(&block)
   end
 
-  # @@reactor_fiber = Fiber.root
-
-  # def suspend
-  #   result = @@reactor_fiber.transfer
-  #   result.is_a?(Exception) ? raise(result) : result
-  # end
-
   def throttled_loop(rate, &block)
     throttler = Throttler.new(rate)
     loop do
@@ -155,7 +131,7 @@ module ::Kernel
   end
 
   def timeout(duration, opts = {}, &block)
-    CancelScope.new(opts.merge(timeout: duration)).(&block)
+    CancelScope.new(**opts, timeout: duration).(&block)
   end
 end