goru 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2052d47d66797e7a2a268ec567209e6e5a41888f3f7e805ed4883f6534c61e72
-  data.tar.gz: c154d10da685ffc931d7e2c3e6385c18c4cd534f593aa286babd02c13296fd6f
+  metadata.gz: 5a78af9c418381f52acab486a5f32205f6ce73fdaf4327954fe551e6ca919b21
+  data.tar.gz: 1185292bd3717ea47388afaa5bd3a914c869ff8ff07132e80b0f118a03e8eff1
 SHA512:
-  metadata.gz: b82cfe65acf08ecb2f584b6eb5817c3dd20ad59474d86525e744e0745d34f46dacfbb66ae73e16897965e43e57d4ac8b39bcc6f61141a686314a5ad9a3f71c42
-  data.tar.gz: a2aae75a244ca2d69acd1102fc42da12519eea8221995ce49b7eb2ff00c4f19ad4a07362efc66d833b28f3335ecc12d26333fd0610278b3b04129a2a4fe4e306
+  metadata.gz: 5ea306fe3b3445a1eabfbfffc4f80d572f9dcecaee129cf2e28bc65e207f3b82b06d355d52431993765703c7e6e8fb959d5ea2886292160b96e781eb8fab48a3
+  data.tar.gz: 497417e7c3dac2ab8454878e4cb869de978942d0bc60b14a908191d84d59be27a514373543f1fe431089eb0393157ae919941dfe210c1b6256f10ea6a5f7c54f

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [v0.1.0](https://github.com/bryanp/goru/releases/tag/v0.1.0)
+
+*released on 2023-03-29*
+
+  * `add` [#1](https://github.com/bryanp/featuring) Initial implementation ([bryanp](https://github.com/bryanp))
+
+

data/README.md

@@ -0,0 +1,226 @@
+**Concurrent routines for Ruby.**
+
+Goru is an experimental concurrency library for Ruby.
+
+* **Lightweight:** Goru routines are not backed by fibers or threads. Each routine creates only ~345 bytes of memory overhead.
+* **Explicit:** Goru requires you to describe exactly how a routine behaves. Less magic makes for fewer bugs when writing concurrent programs.
+
+Goru was intended for low-level programs like http servers and not for direct use in user-facing code.
+
+## How It Works
+
+Routines are defined with initial state and a block that does work and (optionally) updates the state of the routine:
+
+```ruby
+3.times do
+  Goru::Scheduler.go(:running) { |routine|
+    case routine.state
+    when :running
+      routine.update(:sleeping)
+      routine.sleep(rand)
+    when :sleeping
+      puts "[#{object_id}] woke up at #{Time.now.to_f}"
+      routine.update(:running)
+    end
+  }
+end
+```
+
+Routines run concurrently within a reactor, each reactor running in a dedicated thread. Each eligible routine is called
+once on every tick of the reactor it is scheduled to run in. In the example above, the three routines sleep for a random
+interval before waking up and printing the current time. Here is some example output:
+
+```
+[1840] woke up at 1677939216.379147
+[1860] woke up at 1677939217.059535
+[1920] woke up at 1677939217.190349
+[1860] woke up at 1677939217.6196458
+[1920] woke up at 1677939217.935916
+[1840] woke up at 1677939218.033243
+[1860] woke up at 1677939218.532908
+[1920] woke up at 1677939218.8669178
+[1840] woke up at 1677939219.379714
+[1860] woke up at 1677939219.522777
+[1920] woke up at 1677939220.0475688
+[1840] woke up at 1677939220.253979
+```
+
+Each reactor can only run one routine at any given point in time, but if a routine blocks (e.g. by sleeping or
+performing i/o) the reactor calls another eligible routine before returning to the previously blocked routine
+on the next tick.
+
+## Scheduler
+
+By default Goru routines are scheduled in a global scheduler that waits at the end of the program for all routines
+to finish. While this is useful for small scripts, most use-cases will involve creating your own scheduler and
+registering routines directly:
+
+```ruby
+scheduler = Goru::Scheduler.new
+scheduler.go { |routine|
+  ...
+}
+scheduler.wait
+```
+
+Routines are scheduled to run immediately after registration.
+
+### Tuning
+
+Schedulers default to running a number of reactors matching the number of processors on the current system. Tune
+this to your needs with the `count` option when creating a scheduler:
+
+```ruby
+scheduler = Goru::Scheduler.new(count: 3)
+```
+
+## State
+
+Routines are initialized with default state that is useful for coordination between ticks. This is perhaps the
+oddest part of Goru but the explicitness can make it easier to understand exactly how your routines will behave.
+
+Take a look at the [examples](./examples) to get some ideas.
+
+## Finishing
+
+Routines will run forever until you say they are finished:
+
+```ruby
+Goru::Scheduler.go { |routine|
+  routine.finished
+}
+```
+
+### Results
+
+When finishing a routine you can provide a final result:
+
+```ruby
+routines = []
+scheduler = Goru::Scheduler.new
+routines << scheduler.go { |routine| routine.finished(true) }
+routines << scheduler.go { |routine| routine.finished(false) }
+routines << scheduler.go { |routine| routine.finished(true) }
+scheduler.wait
+
+pp routines.map(&:result)
+# [true, false, true]
+```
+
+## Error Handling
+
+Unhandled errors within a routine cause the routine to enter an `:errored` state. Calling `result` on an errored
+routine causes the error to be re-raised. Routines can handle errors elegantly using the `handle` method:
+
+```ruby
+Goru::Scheduler.go { |routine|
+  routine.handle(StandardError) do |event:|
+    # do something with `event`
+  end
+
+  ...
+}
+```
+
+See [`core-handler`](https://github.com/bryanp/corerb/tree/main/handler) for more about error handling.
+
+## Sleeping
+
+Goru implements a non-blocking version of `sleep` that makes the routine ineligible to be called until the sleep time
+has elapsed. It is important to note that Ruby's built-in sleep method will block the reactor and should not be used.
+
+```ruby
+Goru::Scheduler.go { |routine|
+  routine.sleep(3)
+}
+```
+
+Unlike `Kernel#sleep` Goru's sleep method requires a duration.
+
+## Channels
+
+Goru offers buffered reading and writing through channels:
+
+```ruby
+channel = Goru::Channel.new
+
+Goru::Scheduler.go(channel: channel, intent: :w) { |routine|
+  routine << SecureRandom.hex
+}
+
+# This routine is not invoked unless the channel contains data for reading.
+#
+Goru::Scheduler.go(channel: channel, intent: :r) { |routine|
+  value = routine.read
+}
+```
+
+Channels are unbounded by default, meaning they can hold an unlimited amount of data. This behavior can be changed by
+initializing a channel with a specific size. Routines with the intent to write will not be invoked unless the channel
+has space available for writing.
+
+```ruby
+channel = Goru::Channel.new(size: 3)
+
+# This routine is not invoked if the channel is full.
+#
+Goru::Scheduler.go(channel: channel, intent: :w) { |routine|
+  routine << SecureRandom.hex
+}
+```
+
+## IO
+
+Goru includes a pattern for non-blocking io. With it you can implement non-blocking servers, clients, etc.
+
+Routines that involve io must be created with an io object and an intent. Possible intents include:
+
+* `:r` for reading
+* `:r` for writing
+* `:rw` for reading and writing
+
+Here is the beginning of an http server in Goru:
+
+```ruby
+Goru::Scheduler.go(io: TCPServer.new("localhost", 4242), intent: :r) { |server_routine|
+  next unless client = server_routine.accept
+
+  Goru::Scheduler.go(io: client, intent: :r) { |client_routine|
+    next unless data = client_routine.read(16384)
+
+    # do something with `data`
+  }
+}
+```
+
+### Changing Intents
+
+Intents can be changed after a routine is created, e.g. to switch a routine from reading to writing:
+
+```ruby
+Goru::Scheduler.go(io: io, intent: :r) { |routine|
+  routine.intent = :w
+}
+```
+
+## Bridges
+
+Goru supports coordinates buffered io using bridges:
+
+```ruby
+writer = Goru::Channel.new
+
+Goru::Scheduler.go(io: io, intent: :w) { |routine|
+  routine.bridge(writer, intent: :w)
+}
+
+Goru::Scheduler.go(channel: writer) { |routine|
+  routine << SecureRandom.hex
+}
+```
+
+This allows routines to easily write data to a buffer independently of how the data is written to io.
+
+## Credits
+
+Goru was designed while writing a project in Go and imagining what Go-like concurrency might look like in Ruby.

data/lib/goru/channel.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "./reactor"
+
+module Goru
+  class Channel
+    def initialize(size: nil)
+      @size = size
+      @messages = []
+      @closed = false
+      @observers = Set.new
+    end
+
+    # [public]
+    #
+    attr_writer :observer
+
+    # [public]
+    #
+    def <<(message)
+      raise "closed" if @closed
+      @messages << message
+      @observers.each(&:channel_received)
+    end
+
+    # [public]
+    #
+    def read
+      message = @messages.shift
+      @observers.each(&:channel_read)
+      message
+    end
+
+    # [public]
+    #
+    def any?
+      @messages.any?
+    end
+
+    # [public]
+    #
+    def empty?
+      @messages.empty?
+    end
+
+    # [public]
+    #
+    def full?
+      @size && @messages.size == @size
+    end
+
+    # [public]
+    #
+    def closed?
+      @closed == true
+    end
+
+    # [public]
+    #
+    def close
+      @closed = true
+      @observers.each(&:channel_closed)
+    end
+
+    # [public]
+    #
+    def reopen
+      @closed = false
+      @observers.each(&:channel_reopened)
+    end
+
+    # [public]
+    #
+    def clear
+      @messages.clear
+    end
+
+    # [public]
+    #
+    def length
+      @messages.length
+    end
+
+    # [public]
+    #
+    def add_observer(observer)
+      @observers << observer
+    end
+
+    # [public]
+    #
+    def remove_observer(observer)
+      @observers.delete(observer)
+    end
+  end
+end

data/lib/goru/reactor.rb

@@ -5,6 +5,7 @@ require "nio"
 require "timers/group"
 require "timers/wait"
 
+require_relative "routines/bridge"
 require_relative "routines/io"
 
 module Goru
@@ -14,12 +15,13 @@ module Goru
     def initialize(queue:, scheduler:)
       @queue = queue
       @scheduler = scheduler
-      @routines = []
-      @finished = []
+      @routines = Set.new
+      @bridges = Set.new
       @timers = Timers::Group.new
       @selector = NIO::Selector.new
-      @status = nil
       @stopped = false
+      @status = nil
+      @mutex = Mutex.new
     end
 
     # [public]
@@ -29,58 +31,38 @@ module Goru
     # [public]
     #
     def run
-      @status = :running
-
       until @stopped
+        set_status(:running)
+
         @routines.each do |routine|
           call_routine(routine)
         end
 
-        # TODO: Remove the monitor from the selector.
-        #
-        cleanup_finished_routines
-
         begin
-          if (routine = @queue.pop(true))
-            adopt_routine(routine)
-          end
+          wait_for_routine(block: false)
         rescue ThreadError
           interval = @timers.wait_interval
 
           if interval.nil?
             if @routines.empty?
               if @selector.empty?
-                @status = :looking
-                @scheduler.signal(self)
-                if (routine = @queue.pop)
-                  adopt_routine(routine)
-                end
+                become_idle
               else
-                # TODO: The issue doing this is that this reactor won't grab new routines. Will calling `@selector.wakeup`
-                # from the scheduler when a routine is added to the queue resolve this?
-                #
-                @selector.select do |monitor|
-                  monitor.value.call
+                wait_for_bridge do
+                  wait_for_selector
                 end
               end
             else
-              @selector.select(0) do |monitor|
-                monitor.value.call
+              wait_for_bridge do
+                wait_for_selector(0)
               end
             end
           elsif interval > 0
             if @selector.empty?
-              Timers::Wait.for(interval) do |remaining|
-                if (routine = @queue.pop_with_timeout(remaining))
-                  adopt_routine(routine)
-                  break
-                end
-              rescue ThreadError
-                # nothing to do
-              end
+              wait_for_interval(interval)
             else
-              @selector.select(interval) do |monitor|
-                monitor.value.call
+              wait_for_bridge do
+                wait_for_selector(interval)
               end
             end
           end
@@ -90,63 +72,127 @@ module Goru
       end
     ensure
       @selector.close
-      @status = :finished
+      set_status(:finished)
+    end
+
+    private def become_idle
+      set_status(:idle)
+      @scheduler.signal(self)
+      wait_for_routine
+    end
+
+    private def wait_for_selector(timeout = nil)
+      @selector.select(timeout) do |monitor|
+        monitor.value.call
+      end
+    end
+
+    private def wait_for_bridge
+      if @bridges.any?(&:applicable?) && @bridges.none?(&:ready?)
+        wait_for_routine
+      else
+        yield
+      end
+    end
+
+    private def wait_for_interval(timeout)
+      Timers::Wait.for(timeout) do |remaining|
+        break if wait_for_routine(timeout: remaining)
+      rescue ThreadError
+        # nothing to do
+      end
+    end
+
+    private def wait_for_routine(block: true, timeout: nil)
+      if timeout
+        if (routine = @queue.pop(timeout: timeout))
+          adopt_routine(routine)
+        end
+      elsif (routine = @queue.pop(!block))
+        adopt_routine(routine)
+      end
     end
 
     # [public]
     #
-    def stop
-      @stopped = true
+    def finished?
+      @mutex.synchronize do
+        @status == :idle || @status == :stopped
+      end
+    end
 
-      unless @selector.closed?
+    # [public]
+    #
+    def signal
+      unless @selector.empty?
         @selector.wakeup
       end
     end
 
     # [public]
     #
-    def sleep(routine, seconds)
+    def wakeup
+      signal
+      @queue << :wakeup
+    end
+
+    # [public]
+    #
+    def stop
+      @stopped = true
+      @selector.wakeup
+    rescue IOError
+    end
+
+    # [public]
+    #
+    def routine_asleep(routine, seconds)
       @timers.after(seconds) {
         routine.wake
       }
     end
 
-    private def adopt_routine(routine)
-      routine.reactor = self
-
+    # [public]
+    #
+    def adopt_routine(routine)
       case routine
       when Routines::IO
         monitor = @selector.register(routine.io, routine.intent)
-
-        monitor.value = proc {
-          # TODO: Try to combine this with `call_routine` below.
-          #
-          case routine.status
-          when :selecting
-            routine.call
-          else
-            @finished << routine
-          end
-        }
-      else
+        monitor.value = routine
+        routine.monitor = monitor
+        routine.reactor = self
+      when Routines::Bridge
+        routine.reactor = self
+        @bridges << routine
+      when Routine
+        routine.reactor = self
         @routines << routine
       end
     end
 
-    private def call_routine(routine)
-      case routine.status
-      when :running
-        routine.call
-      when :sleeping, :selecting
-        # ignore these
+    # [public]
+    #
+    def routine_finished(routine)
+      case routine
+      when Routines::Bridge
+        @bridges.delete(routine)
+      when Routines::IO
+        @selector.deregister(routine.io)
       else
-        @finished << routine
+        @routines.delete(routine)
+      end
+    end
+
+    private def set_status(status)
+      @mutex.synchronize do
+        @status = status
       end
     end
 
-    private def cleanup_finished_routines
-      until @finished.empty?
-        @routines.delete(@finished.pop)
+    private def call_routine(routine)
+      case routine.status
+      when :ready
+        routine.call
       end
     end
   end

data/lib/goru/routine.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
+require "is/handler"
+
 module Goru
   # [public]
   #
   class Routine
+    include Is::Handler
+
+    handle(StandardError) do |event:|
+      $stderr << <<~ERROR
+        [goru] routine crashed: #{event}
+        #{event.backtrace.join("\n")}
+      ERROR
+    end
+
     def initialize(state = nil, &block)
       @state = state
       @block = block
-      @status = :running
+      set_status(:ready)
       @result, @error, @reactor = nil
     end
 
@@ -17,12 +28,9 @@ module Goru
 
     # [public]
     #
-    attr_writer :reactor
-
-    # [public]
-    #
-    def running?
-      @status == :running
+    def reactor=(reactor)
+      @reactor = reactor
+      status_changed
     end
 
     # [public]
@@ -30,11 +38,9 @@ module Goru
     def call
       @block.call(self)
     rescue => error
-      puts "[routine error] #{error}"
-      puts error.backtrace
-
       @error = error
-      @status = :errored
+      set_status(:errored)
+      trigger(error)
     end
 
     # [public]
@@ -42,7 +48,7 @@ module Goru
     def finished(result = nil)
       unless @finished
         @result = result
-        @status = :finished
+        set_status(:finished)
       end
     end
 
@@ -66,14 +72,30 @@ module Goru
     # [public]
     #
     def sleep(seconds)
-      @status = :sleeping
-      @reactor.sleep(self, seconds)
+      set_status(:idle)
+      @reactor.routine_asleep(self, seconds)
     end
 
     # [public]
     #
     def wake
-      @status = :running
+      set_status(:ready)
+    end
+
+    # [public]
+    #
+    private def set_status(status)
+      @status = status
+      status_changed
+    end
+
+    # [public]
+    #
+    private def status_changed
+      case @status
+      when :finished
+        @reactor&.routine_finished(self)
+      end
     end
   end
 end

data/lib/goru/routines/bridge.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "../routine"
+
+module Goru
+  module Routines
+    # [public]
+    #
+    class Bridge < Routine
+      def initialize(state = nil, routine:, channel:, &block)
+        super(state, &block)
+
+        @routine = routine
+        @channel = channel
+        @channel.add_observer(self)
+      end
+
+      # [public]
+      #
+      def ready?
+        @status == :ready
+      end
+
+      private def status_changed
+        case @status
+        when :finished
+          @channel.remove_observer(self)
+        end
+
+        super
+      end
+
+      def channel_received
+        update_status
+      end
+
+      def channel_read
+        update_status
+      end
+
+      def channel_closed
+        update_status
+      end
+
+      def channel_reopened
+        update_status
+      end
+    end
+  end
+end

data/lib/goru/routines/bridges/readable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../bridge"
+
+module Goru
+  module Routines
+    module Bridges
+      class Readable < Bridge
+        def initialize(...)
+          super
+
+          update_status
+        end
+
+        # [public]
+        #
+        def applicable?
+          @routine.intent == :r
+        end
+
+        private def update_status
+          status = if @routine.status == :finished
+            :finished
+          elsif @channel.full?
+            :idle
+          elsif @channel.closed?
+            :idle
+          else
+            :ready
+          end
+
+          set_status(status)
+        end
+      end
+    end
+  end
+end

data/lib/goru/routines/bridges/writable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../bridge"
+
+module Goru
+  module Routines
+    module Bridges
+      class Writable < Bridge
+        def initialize(...)
+          super
+
+          update_status
+        end
+
+        # [public]
+        #
+        def applicable?
+          @routine.intent == :w
+        end
+
+        private def update_status
+          status = if @routine.status == :finished
+            :finished
+          elsif @channel.any?
+            :ready
+          elsif @channel.closed?
+            :finished
+          else
+            :idle
+          end
+
+          set_status(status)
+        end
+      end
+    end
+  end
+end

data/lib/goru/routines/channel.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../routine"
+
+module Goru
+  module Routines
+    # [public]
+    #
+    class Channel < Routine
+      def initialize(state = nil, channel:, &block)
+        super(state, &block)
+
+        @channel = channel
+        @channel.add_observer(self)
+      end
+
+      private def status_changed
+        case @status
+        when :ready
+          @reactor&.wakeup
+        when :finished
+          @channel.remove_observer(self)
+        end
+
+        super
+      end
+
+      def channel_received
+        update_status
+      end
+
+      def channel_read
+        update_status
+      end
+
+      def channel_closed
+        update_status
+      end
+
+      def channel_reopened
+        update_status
+      end
+    end
+  end
+end

data/lib/goru/routines/channels/readable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../channel"
+
+module Goru
+  module Routines
+    module Channels
+      # [public]
+      #
+      class Readable < Channel
+        def initialize(...)
+          super
+
+          update_status
+        end
+
+        # [public]
+        #
+        def read
+          @channel.read
+        end
+
+        private def update_status
+          status = if @channel.any?
+            :ready
+          elsif @channel.closed?
+            :finished
+          else
+            :idle
+          end
+
+          set_status(status)
+        end
+      end
+    end
+  end
+end

data/lib/goru/routines/channels/writable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../channel"
+
+module Goru
+  module Routines
+    module Channels
+      # [public]
+      #
+      class Writable < Channel
+        def initialize(...)
+          super
+
+          update_status
+        end
+
+        # [public]
+        #
+        def <<(message)
+          @channel << message
+        end
+
+        private def update_status
+          status = if @channel.full?
+            :idle
+          elsif @channel.closed?
+            :idle
+          else
+            :ready
+          end
+
+          set_status(status)
+        end
+      end
+    end
+  end
+end

data/lib/goru/routines/io.rb

@@ -1,24 +1,30 @@
 # frozen_string_literal: true
 
 require_relative "../routine"
+require_relative "bridges/readable"
+require_relative "bridges/writable"
 
 module Goru
   module Routines
     # [public]
     #
     class IO < Routine
-      def initialize(state = nil, io:, intent: :rw, &block)
+      def initialize(state = nil, io:, intent:, &block)
         super(state, &block)
 
         @io = io
-        @intent = intent
+        @intent = normalize_intent(intent)
         @status = :selecting
+        @monitor = nil
+        @finishers = []
       end
 
       # [public]
       #
       attr_reader :io, :intent
 
+      attr_writer :monitor
+
       # [public]
       #
       def accept
@@ -31,11 +37,89 @@ module Goru
         result = @io.read_nonblock(bytes, exception: false)
 
         case result
-        when :wait_readable, nil
+        when nil
+          finished
+          nil
+        when :wait_readable
           # nothing to do
         else
           result
         end
+      rescue Errno::ECONNRESET
+        finished
+        nil
+      end
+
+      # [public]
+      #
+      def write(data)
+        result = @io.write_nonblock(data, exception: false)
+
+        case result
+        when nil
+          finished
+          nil
+        when :wait_writable
+          # nothing to do
+        else
+          result
+        end
+      rescue Errno::ECONNRESET
+        finished
+        nil
+      end
+
+      # [public]
+      #
+      def intent=(intent)
+        intent = normalize_intent(intent)
+        validate_intent!(intent)
+
+        @monitor.interests = intent
+        @intent = intent
+      end
+
+      # [public]
+      #
+      def bridge(channel, intent:)
+        intent = normalize_intent(intent)
+        validate_intent!(intent)
+
+        bridge = case intent
+        when :r
+          Bridges::Readable.new(routine: self, channel: channel)
+        when :w
+          Bridges::Writable.new(routine: self, channel: channel)
+        end
+
+        on_finished { bridge.finished }
+        @reactor.adopt_routine(bridge)
+        bridge
+      end
+
+      # [public]
+      #
+      def on_finished(&block)
+        @finishers << block
+      end
+
+      private def status_changed
+        case @status
+        when :finished
+          @finishers.each(&:call)
+        end
+
+        super
+      end
+
+      INTENTS = %i[r w].freeze
+
+      private def validate_intent!(intent)
+        raise ArgumentError, "unknown intent: #{intent}" unless INTENTS.include?(intent)
+      end
+
+      private def normalize_intent(intent)
+        intent.to_sym
       end
     end
   end

data/lib/goru/scheduler.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+require "etc"
 require "is/global"
 
-require_relative "queue"
+require_relative "channel"
 require_relative "reactor"
+require_relative "routines/channel"
 require_relative "routines/io"
 
+require_relative "routines/channels/readable"
+require_relative "routines/channels/writable"
+
 module Goru
   # [public]
   #
@@ -13,14 +18,30 @@ module Goru
     include Is::Global
     include MonitorMixin
 
-    def initialize(...)
-      super
+    class << self
+      # Prevent issues when including `Goru` at the toplevel.
+      #
+      # [public]
+      #
+      def go(...)
+        global.go(...)
+      end
+
+      # [public]
+      #
+      def default_scheduler_count
+        Etc.nprocessors
+      end
+    end
+
+    def initialize(count: self.class.default_scheduler_count)
+      super()
 
       @stopping = false
-      @routines = Queue.new
+      @routines = Thread::Queue.new
       @condition = new_cond
 
-      @reactors = 10.times.map {
+      @reactors = count.times.map {
         Reactor.new(queue: @routines, scheduler: self)
       }
 
@@ -35,12 +56,26 @@ module Goru
 
     # [public]
     #
-    def go(state = nil, io: nil, intent: :rw, &block)
-      @routines << if io
+    def go(state = nil, io: nil, channel: nil, intent: nil, &block)
+      raise ArgumentError, "cannot set both `io` and `channel`" if io && channel
+
+      routine = if io
         Routines::IO.new(state, io: io, intent: intent, &block)
+      elsif channel
+        case intent
+        when :r
+          Routines::Channels::Readable.new(state, channel: channel, &block)
+        when :w
+          Routines::Channels::Writable.new(state, channel: channel, &block)
+        end
       else
         Routine.new(state, &block)
       end
+
+      @routines << routine
+      @reactors.each(&:signal)
+
+      routine
     end
 
     # [public]
@@ -51,6 +86,7 @@ module Goru
           @stopping
         end
       end
+    rescue Interrupt
     ensure
       stop
     end
@@ -68,7 +104,7 @@ module Goru
     #
     def signal(reactor)
       synchronize do
-        if @reactors.all? { |reactor| reactor.status == :looking || reactor.status == :stopped }
+        if @reactors.all?(&:finished?)
           @stopping = true
         end
 

data/lib/goru/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Goru
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 
   # [public]
   #

data/lib/goru.rb

@@ -8,8 +8,8 @@ module Goru
 
   extend Is::Extension
 
-  def go(state = nil, io: nil, intent: :rw, &block)
-    Scheduler.go(state, io: io, intent: intent, &block)
+  def go(state = nil, io: nil, channel: nil, intent: nil, &block)
+    Scheduler.go(state, io: io, channel: channel, intent: intent, &block)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goru
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-06 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-extension
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: core-global
+  name: core-handler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: core-global
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
@@ -67,20 +81,28 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '4.3'
 description: Concurrent routines for Ruby.
-email: bryan@metabahn.com
+email: bryan@bryanp.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
+- README.md
 - lib/goru.rb
-- lib/goru/queue.rb
+- lib/goru/channel.rb
 - lib/goru/reactor.rb
 - lib/goru/routine.rb
+- lib/goru/routines/bridge.rb
+- lib/goru/routines/bridges/readable.rb
+- lib/goru/routines/bridges/writable.rb
+- lib/goru/routines/channel.rb
+- lib/goru/routines/channels/readable.rb
+- lib/goru/routines/channels/writable.rb
 - lib/goru/routines/io.rb
 - lib/goru/scheduler.rb
 - lib/goru/version.rb
-homepage: https://github.com/metabahn/goru/
+homepage: https://github.com/bryanp/goru/
 licenses:
 - MPL-2.0
 metadata: {}
@@ -92,14 +114,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.7
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.4.9
 signing_key:
 specification_version: 4
 summary: Concurrent routines for Ruby.

data/lib/goru/queue.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Goru
-  # [public] Based on: https://spin.atomicobject.com/2017/06/28/queue-pop-with-timeout-fixed/
-  #
-  class Queue
-    def initialize
-      @mutex = Mutex.new
-      @queue = []
-      @received = ConditionVariable.new
-      @closed = false
-    end
-
-    # [public]
-    #
-    def <<(x)
-      @mutex.synchronize do
-        @queue << x
-        @received.signal
-      end
-    end
-
-    # [public]
-    #
-    def pop(non_block = false)
-      pop_with_timeout(non_block ? 0 : nil)
-    end
-
-    # [public]
-    #
-    def pop_with_timeout(timeout = nil)
-      @mutex.synchronize do
-        if timeout.nil?
-          # wait indefinitely until there is an element in the queue
-          while @queue.empty? && !@closed
-            @received.wait(@mutex)
-          end
-        elsif @queue.empty? && !@closed && timeout != 0
-          # wait for element or timeout
-          timeout_time = timeout + Time.now.to_f
-          while @queue.empty? && (remaining_time = timeout_time - Time.now.to_f) > 0
-            @received.wait(@mutex, remaining_time)
-          end
-        end
-        return if @closed
-        # if we're still empty after the timeout, raise exception
-        raise ThreadError, "queue empty" if @queue.empty?
-        @queue.shift
-      end
-    end
-
-    # [public]
-    #
-    def close
-      @mutex.synchronize do
-        @closed = true
-        @received.broadcast
-      end
-    end
-  end
-end