polyphony 0.43.8

data/examples/adapters/redis_blpop.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+# require 'redis'
+
+redis = Redis.new(host: ENV['REDISHOST'] || 'localhost')
+
+redis.lpush("queue_key", "omgvalue")
+puts "len: #{redis.llen("queue_key")}"
+result = redis.blpop("queue_key")
+puts result.inspect

data/examples/adapters/redis_channels.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+
+class RedisChannel < Polyphony::Channel
+  def self.publish_connection
+    @publish_connection ||= Redis.new
+  end
+
+  def self.subscribe_connection
+    @subscribe_connection ||= Redis.new
+  end
+
+  CHANNEL_MASTER_TOPIC = 'channel_master'
+
+  def self.start_monitor
+    @channels = {}
+    @monitor = spin do
+      subscribe_connection.subscribe(CHANNEL_MASTER_TOPIC) do |on|
+        on.message do |topic, message|
+          message = Marshal.load(message)
+          topic == if CHANNEL_MASTER_TOPIC
+                     handle_master_message(message)
+                   else
+                     handle_channel_message(topic, message)
+                   end
+        end
+      end
+    end
+  end
+
+  def self.stop_monitor
+    @monitor&.interrupt
+  end
+
+  def self.handle_master_message(message)
+    case message[:kind]
+    when :subscribe
+      subscribe_connection.subscribe(message[:topic])
+    when :unsubscribe
+      subscribe_connection.unsubscribe(message[:topic])
+    end
+  end
+
+  def self.handle_channel_message(topic, message)
+    channel = @channels[topic]
+    channel&.did_receive(message)
+  end
+
+  def self.watch(channel)
+    @channels[channel.topic] = channel
+    spin do
+      publish_connection.publish(CHANNEL_MASTER_TOPIC, Marshal.dump(
+                                                         kind:  :subscribe,
+                                                         topic: channel.topic
+                                                       ))
+    end
+  end
+
+  def self.unwatch(channel)
+    @channels.delete(channel.topic)
+    spin do
+      publish_connection.publish(CHANNEL_MASTER_TOPIC, Marshal.dump(
+                                                         kind:  :unsubscribe,
+                                                         topic: channel.topic
+                                                       ))
+    end
+  end
+
+  def self.channel_topic(channel)
+    "channel_#{channel.object_id}"
+  end
+
+  attr_reader :topic
+
+  def initialize(topic)
+    @topic = topic
+    @waiting_queue = []
+    RedisChannel.watch(self)
+  end
+
+  def close
+    super
+    RedisChannel.unwatch(self)
+  end
+
+  def <<(o)
+    RedisChannel.publish_connection.publish(@topic, Marshal.dump(o))
+  end
+
+  def did_receive(o)
+    @waiting_queue.shift&.schedule(o)
+  end
+
+  def receive
+    @waiting_queue << Fiber.current
+    suspend
+  end
+end
+
+RedisChannel.start_monitor
+channel = RedisChannel.new('channel1')
+
+spin do
+  loop do
+    message = channel.receive
+    puts "got message: #{message}"
+  end
+end
+
+spin do
+  move_on_after(3) do
+    throttled_loop(1) do
+      channel << Time.now
+    end
+  end
+  channel.close
+  RedisChannel.stop_monitor
+end
+
+suspend

data/examples/adapters/redis_client.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+
+redis = Redis.new
+
+X = 10
+
+t0 = Time.now
+X.times { redis.get('abc') }
+puts "get rate: #{X / (Time.now - t0)} reqs/s"
+
+puts "abc = #{redis.get('abc')}"
+
+puts 'updating value...'
+redis.set('abc', Time.now.to_s)
+
+puts "abc = #{redis.get('abc')}"

data/examples/adapters/redis_pubsub.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+
+spin do
+  redis = Redis.new
+  redis.subscribe('redis-channel') do |on|
+    on.message do |channel, message|
+      puts "##{channel}: #{message}"
+      redis.unsubscribe if message == 'exit'
+    end
+  end
+end
+
+spin do
+  redis = Redis.new
+  move_on_after(3) do
+    throttled_loop(1) do
+      redis.publish('redis-channel', Time.now)
+    end
+  end
+  redis.publish('redis-channel', 'exit')
+end
+
+suspend

data/examples/adapters/redis_pubsub_perf.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+require 'json'
+
+X_SESSIONS = 1000
+X_NODES = 10_000
+X_SUBSCRIPTIONS_PER_SESSION = 100
+
+$sessions = []
+X_SESSIONS.times do
+  $sessions << {
+    subscriptions: X_SUBSCRIPTIONS_PER_SESSION.times.map do
+      "node#{rand(X_NODES)}"
+    end.uniq
+  }
+end
+
+spin do
+  redis = Redis.new
+  redis.subscribe('events') do |on|
+    on.message do |_, message|
+      distribute_event(JSON.parse(message, symbolize_names: true))
+    end
+  end
+end
+
+$update_count = 0
+
+def distribute_event(event)
+  $update_count += 1
+  # t0 = Time.now
+  count = 0
+  $sessions.each do |s|
+    count += 1 if s[:subscriptions].include?(event[:path])
+  end
+  # elapsed = Time.now - t0
+  # rate = X_SESSIONS / elapsed
+  # puts "elapsed: #{elapsed} (#{rate}/s)" if $update_count % 100 == 0
+end
+
+spin do
+  redis = Redis.new
+  throttled_loop(1000) do
+    redis.publish('events', { path: "node#{rand(X_NODES)}" }.to_json)
+  end
+end
+
+spin do
+  last_count = 0
+  last_stamp = Time.now
+  throttled_loop(1) do
+    now = Time.now
+    elapsed = now - last_stamp
+    delta = $update_count - last_count
+    puts "update rate: #{delta.to_f / elapsed}"
+    last_stamp = now
+    last_count = $update_count
+  end
+end
+
+trap(:int) do
+  puts 'bye...'
+  exit!
+end
+
+suspend

data/examples/core/01-spinning-up-fibers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'polyphony'
+
+def nap(tag, t)
+  puts "#{Time.now} #{tag} napping for #{t} seconds..."
+  sleep t
+  puts "#{Time.now} #{tag} done napping"
+end
+
+# We launch two concurrent fibers, each sleeping for the given duration.
+spin { nap(:a, 1) }
+spin { nap(:b, 2) }
+
+# Calling suspend will block until all child fibers have terminated
+suspend

data/examples/core/02-awaiting-fibers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+sleeper = spin do
+  puts 'going to sleep'
+  sleep 1
+  puts 'woke up'
+end
+
+# One way to synchronize fibers is by using `Fiber#await`, which blocks
+# until the fiber has finished running or has been interrupted.
+waiter = spin do
+  puts 'waiting for fiber to terminate'
+  sleeper.await
+  puts 'done waiting'
+end
+
+waiter.await

data/examples/core/03-interrupting.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+# Let's see how a long-running blocking operation can be interrupted. Polyphony
+# provides several APIs for interrupting an ongoing operation, and distinguishes
+# between two different types of interruptions: *cancel* and *move on*. A
+# *cancel* will interrupt an ongoing operation and raise an exception. A *move
+# on* will interrupt an ongoing operation without raising an exception,
+# optionally returning an arbitrary value as the result of that operation.
+
+def nap(tag, t)
+  puts "#{Time.now} #{tag} napping for #{t} seconds..."
+  sleep t
+ensure
+  puts "#{Time.now} #{tag} done napping"
+end
+
+# The Kernel#cancel_after interrupts a blocking operation by raising a
+# Polyphony::Cancel exception after the given timeout. If not rescued, the
+# exception is propagated up the fiber hierarchy
+spin do
+  # cancel after 1 second
+  cancel_after(1) { nap(:cancel, 2) }
+rescue Polyphony::Cancel => e
+  puts "got exception: #{e}"
+end
+
+# The Kernel#move_on_after interrupts a blocking operation by raising a
+# Polyphony::MoveOn exception, which is silently swallowed by the fiber
+spin do
+  # move on after 1 second
+  move_on_after(1) do
+    nap(:move_on, 2)
+  end
+end
+
+suspend

data/examples/core/04-handling-signals.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+# trap('TERM') do
+#   Polyphony.emit_signal_exception(::SystemExit)
+# end
+
+# trap('INT') do
+#   Polyphony.emit_signal_exception(::Interrupt)
+# end
+
+puts "go to sleep"
+begin
+  sleep
+ensure
+  puts "done sleeping"
+end

data/examples/core/xx-agent.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+class Test
+  def test_sleep
+    puts "going to sleep"
+    sleep 1
+    puts "done sleeping"
+  end
+  
+  def test_spin
+    spin {
+      10.times {
+        STDOUT << '.'
+        sleep 0.1
+      }
+    }
+    
+    puts "going to sleep\n"
+    sleep 1
+    puts 'woke up'
+  end
+  
+  def test_file
+    f = File.open(__FILE__, 'r')
+    puts Thread.current.agent.read(f, +'', 10000, true)
+    
+    Thread.current.agent.write(STDOUT, "Write something: ")
+    str = +''
+    Thread.current.agent.read(STDIN, str, 5, false)
+    puts str
+  end
+  
+  def test_fork
+    pid = fork do
+      Thread.current.agent.post_fork
+      puts 'child going to sleep'
+      sleep 1
+      puts 'child done sleeping'
+      exit(42)
+    end
+    
+    puts "Waiting for pid #{pid}"
+    result = Thread.current.agent.waitpid(pid)
+    puts "Done waiting"
+    p result
+  end
+  
+  def test_async
+    async = Polyphony::Event.new
+    
+    spin {
+      puts "signaller starting"
+      sleep 1
+      puts "signal"
+      async.signal(:foo)
+    }
+    
+    puts "awaiting event"
+    p async.await
+  end
+  
+  def test_queue
+    q = Gyro::Queue.new
+    spin {
+      10.times {
+        q << Time.now.to_f
+        sleep 0.2
+      }
+      q << :STOP
+    }
+    
+    loop do
+      value = q.shift
+      break if value == :STOP
+      
+      p value
+    end
+  end
+  
+  def test_thread
+    t = Thread.new do
+      puts "thread going to sleep"
+      sleep 0.2
+      puts "thread done sleeping"
+    end
+    
+    t.await
+  end
+end
+
+t = Test.new
+
+t.methods.select { |m| m =~ /^test_/ }.each do |m|
+  puts '*' * 40
+  puts m
+  t.send(m)
+end