polyphony 0.43.4 → 0.43.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9481b252526ebc3f8e0f5a0121eebb68492bc0c1502cfed447da7b0648e6095b
-  data.tar.gz: dfd2d5d0415833f14f9ebe2cc6336e87d0951ce86f07ebcdec0ad892f71fb74c
+  metadata.gz: b3000a280d995b187518c1e12f585939b4e67312db5458d105c6e6b40c784d5a
+  data.tar.gz: 5a582fc77ae044238521619b1d5364a0dd2aac13ca8a6b82d006ec1f23284d2d
 SHA512:
-  metadata.gz: 652633b1fc27623edb2e87b5657322ba4826ec176e8eb5131a43249e08340f793ba426743be343bfe0fce02fc60b73cb790afef816a4153585d68bdfeaa9c55d
-  data.tar.gz: 946abb7526324cae5f1d6b62e25c8410129b07ca75c82a6b7285d6269ed1911e161a6030a394ef29ba238a80da6f96787dd94fdbd5c05bd2a643379252ce80d0
+  metadata.gz: 6d403109b1bbf55e1b0ab799d8c74752677784ca0c12cb5b1e21f62c9bdd244245966db8020b20a8d4ed988263a9535aef5a8aff24b50587c9583a67109d7677
+  data.tar.gz: 205d6c9859ec8d12ddf7630cbd3893a13d3efb3537dd734e53f17efe31d52399488761da45684d0da7e5074ce950c47a7e51f4a1446577e36f7c3c7838604a7a

data/.github/workflows/test.yml

@@ -1,6 +1,6 @@
 name: Tests
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   build:

data/CHANGELOG.md

@@ -1,3 +1,48 @@
+## 0.43.10 2020-07-23
+
+* Fix race condition when terminating fibers (#33)
+* Fix lock release in `Mutex` (#32)
+* Virtualize agent interface
+* Implement `LibevAgent_connect`
+
+## 0.43.9 2020-07-22
+
+* Rewrite `Channel` using `Queue`
+* Rewrite `Mutex` using `Queue`
+* Reimplement `Event` in C to prevent cross-thread race condition
+* Reimplement `ResourcePool` using `Queue`
+* Implement `Queue#size`
+
+## 0.43.8 2020-07-21
+
+* Rename `LibevQueue` to `Queue`
+* Reimplement Event using `Agent#wait_event`
+* Improve Queue shift queue performance
+* Introduce `Agent#wait_event` API for waiting on asynchronous events
+* Minimize `fcntl` syscalls in IO operations 
+
+## 0.43.7 2020-07-20
+
+* Fix memory leak in ResourcePool (#31)
+* Check and adjust file position before reading (#30)
+* Minor documentation fixes
+
+## 0.43.6 2020-07-18
+
+* Allow brute-force interrupting with second Ctrl-C
+* Fix outgoing SSL connections (#28)
+* Improve Fiber#await_all_children with many children
+* Use `writev` for writing multiple strings
+* Add logo (thanks [Gerald](https://webocube.com/)!)
+
+## 0.43.5 2020-07-13
+
+* Fix `#read_nonblock`, `#write_nonblock` for `IO` and `Socket` (#27)
+* Patch `Kernel#p`, `IO#puts` to issue single write call
+* Add support for multiple arguments in `IO#write` and `LibevAgent#write`
+* Use LibevQueue for fiber run queue
+* Reimplement LibevQueue as ring buffer
+
 ## 0.43.4 2020-07-09
 
 * Reimplement Kernel#trap

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.43.4)
+    polyphony (0.43.10)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,8 +1,25 @@
-# Polyphony - Fine-Grained Concurrency for Ruby
+<h1 align="center">
+  <a href="https://digital-fabric.github.io/polyphony/">
+    <img src="docs/polyphony-logo.png" alt="Polyphony">
+  </a>
+  <br>
+  Polyphony
+  <br>
+</h1>
 
-[![Gem Version](https://badge.fury.io/rb/polyphony.svg)](http://rubygems.org/gems/polyphony)
-[![Modulation Test](https://github.com/digital-fabric/polyphony/workflows/Tests/badge.svg)](https://github.com/digital-fabric/polyphony/actions?query=workflow%3ATests)
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/polyphony/blob/master/LICENSE)
+<h4 align="center">Fine-Grained Concurrency for Ruby</h4>
+
+<p align="center">
+  <a href="http://rubygems.org/gems/polyphony">
+    <img src="https://badge.fury.io/rb/polyphony.svg" alt="Ruby gem">
+  </a>
+  <a href="https://github.com/digital-fabric/polyphony/actions?query=workflow%3ATests">
+    <img src="https://github.com/digital-fabric/polyphony/workflows/Tests/badge.svg" alt="Tests">
+  </a>
+  <a href="https://github.com/digital-fabric/polyphony/blob/master/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="MIT License">
+  </a>
+</p>
 
 [DOCS](https://digital-fabric.github.io/polyphony/) |
 [EXAMPLES](examples)

data/TODO.md

@@ -1,9 +1,4 @@
-## 0.43 
-
-- Reimplement ResourcePool, Channel, Mutex using LibevQueue
--- Add `Fiber#schedule_with_priority` method, aliased by `Fiber#wakeup`
-- Implement agent interface is virtual function table
-- Implement proxy agent for plugging in a user-provided agent class
+-- Add `Fiber#schedule_with_priority` method
 
 - Debugging
   - Eat your own dogfood: need a good tool to check what's going on when some

data/bin/stress.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+`rake recompile`
+
+count = ARGV[0] ? ARGV[0].to_i : 100
+
+TEST_CMD = 'ruby test/run.rb'
+
+def run_test(count)
+  puts "#{count}: running tests..."
+  system(TEST_CMD)
+  return if $?.exitstatus == 0
+
+  puts "Failure after #{count} tests"
+  exit!
+end
+
+trap('INT') { exit! }
+t0 = Time.now
+count.times { |i| run_test(i + 1) }
+elapsed = Time.now - t0
+puts format(
+  "Successfully ran %d tests in %f seconds (%f per test)",
+  count,
+  elapsed,
+  elapsed / count
+)

data/docs/_includes/head.html

@@ -0,0 +1,40 @@
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=Edge">
+
+  {% unless site.plugins contains "jekyll-seo-tag" %}
+    <title>{{ page.title }} - {{ site.title }}</title>
+
+    {% if page.description %}
+      <meta name="Description" content="{{ page.description }}">
+    {% endif %}
+  {% endunless %}
+
+  <link rel="shortcut icon" href="{{ 'polyphony-logo.png' | absolute_url }}" type="image/png">
+
+  <link rel="stylesheet" href="{{ '/assets/css/just-the-docs-default.css' | absolute_url }}">
+
+  {% if site.ga_tracking != nil %}
+    <script async src="https://www.googletagmanager.com/gtag/js?id={{ site.ga_tracking }}"></script>
+    <script>
+      window.dataLayer = window.dataLayer || [];
+      function gtag(){dataLayer.push(arguments);}
+      gtag('js', new Date());
+
+      gtag('config', '{{ site.ga_tracking }}'{% unless site.ga_tracking_anonymize_ip == nil %}, { 'anonymize_ip': true }{% endunless %});
+    </script>
+
+  {% endif %}
+
+  {% if site.search_enabled != false %}
+    <script type="text/javascript" src="{{ '/assets/js/vendor/lunr.min.js' | absolute_url }}"></script>
+  {% endif %}
+  <script type="text/javascript" src="{{ '/assets/js/just-the-docs.js' | absolute_url }}"></script>
+
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+
+  {% seo %}
+
+  {% include head_custom.html %}
+
+</head>

data/docs/_includes/title.html

@@ -0,0 +1 @@
+<img src="{{ 'polyphony-logo.png' | absolute_url }}" style="height: 1.5em; margin-right: 0.5em">Polyphony

data/docs/_user-guide/web-server.md

@@ -26,9 +26,9 @@ the entire request body.
 ## A basic web server
 
 ```ruby
-require 'polyphony/http'
+require 'tipi'
 
-Polyphony::HTTP::Server.serve('0.0.0.0', 1234) do |request|
+Tipi.serve('0.0.0.0', 1234) do |request|
   request.respond("Hello world!\n")
 end
 ```
@@ -55,13 +55,13 @@ TLS termination can be handled by passing a `secure_context` option to the
 server:
 
 ```ruby
-require 'polyphony/http'
+require 'tipi'
 require 'localhost/authority'
 
 authority = Localhost::Authority.fetch
 opts = { secure_context: authority.server_context }
 
-Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) do |request|
+Tipi.serve('0.0.0.0', 1234, opts) do |request|
   request.respond("Hello world!\n")
 end
 ```
@@ -72,8 +72,8 @@ Polyphony's web server makes it really easy to integrate websocket communication
 with normal HTTP processing:
 
 ```ruby
-require 'polyphony/http'
-require 'polyphony/websocket'
+require 'tipi'
+require 'tipi/websocket'
 
 ws_handler = Polyphony::Websocket.handler do |ws|
   while (msg = ws.recv)
@@ -85,7 +85,7 @@ opts = {
   upgrade: { websocket: ws_handler }
 }
 
-Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) do |request|
+Tipi.serve('0.0.0.0', 1234, opts) do |request|
   request.respond("Hello world!\n")
 end
 ```
@@ -93,7 +93,7 @@ end
 Polyphony also supports general-purpose HTTP upgrades using the same mechanism:
 
 ```ruby
-require 'polyphony/http'
+require 'tipi'
 
 opts = {
   upgrade: {
@@ -105,7 +105,7 @@ opts = {
   }
 }
 
-Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts) do |request|
+Tipi.serve('0.0.0.0', 1234, opts) do |request|
   request.respond("Hello world!\n")
 end
 ```
@@ -117,7 +117,7 @@ and enables streaming (using chunked encoding for HTTP/1.1 connections). Here's
 an example of an SSE response:
 
 ```ruby
-require 'polyphony/http'
+require 'tipi'
 
 def sse_response(request)
   request.send_headers('Content-Type': 'text/event-stream')
@@ -131,6 +131,6 @@ ensure
   request.send_chunk("retry: 0\n\n", done: true)
 end
 
-Polyphony::HTTP::Server.serve('0.0.0.0', 1234, &method(:sse_response))
+Tipi.serve('0.0.0.0', 1234, &method(:sse_response))
 ```
 

data/docs/getting-started/overview.md

@@ -113,8 +113,8 @@ active concurrent connections, each advancing at its own pace, consuming only a
 single CPU core.
 
 Nevertheless, Polyphony fully supports multithreading, with each thread having
-its own fiber run queue and its own libev event loop. In addition, Polyphony
-enables cross-thread communication using  
+its own fiber run queue and its own libev event loop. Polyphony even enables
+cross-thread communication using [fiber messaging](#message-passing). 
 
 ## Fibers vs Callbacks
 

data/docs/index.md

@@ -6,6 +6,8 @@ permalink: /
 next_title: Installing Polyphony
 ---
 
+<p align="center"><img src="{{ 'polyphony-logo.png' | absolute_url }}" /></p>
+
 # Polyphony
 {:.text-center .logo-title}
 
@@ -18,11 +20,10 @@ implements a comprehensive
 using [libev](https://github.com/enki/libev) as a high-performance event reactor
 for I/O, timers, and other asynchronous events.
 
+[Overview](getting-started/overview){: .btn .btn-green .text-gamma }
 [Take the tutorial](getting-started/tutorial){: .btn .btn-blue .text-gamma }
-[Main Concepts](main-concepts/concurrency/){: .btn .btn-green .text-gamma }
-[FAQ](faq){: .btn .btn-green .text-gamma }
 [Source code](https://github.com/digital-fabric/polyphony){: .btn .btn-purple .text-gamma target="_blank" }
-{: .mt-6 .h-align-center }
+{:.text-center .mt-6 .h-align-center }
 
 ## Focused on Developer Happiness
 

data/docs/main-concepts/design-principles.md

@@ -6,7 +6,7 @@ parent: Main Concepts
 permalink: /main-concepts/design-principles/
 prev_title: Extending Polyphony
 ---
-# The Design of Polyphony 
+# The Design of Polyphony
 
 Polyphony is a new gem that aims to enable developing high-performance
 concurrent applications in Ruby using a fluent, compact syntax and API.
@@ -47,7 +47,7 @@ Nevertheless, while work is being done to harness fibers for providing a better
 way to do concurrency in Ruby, fibers remain a mistery for most Ruby
 programmers, a perplexing unfamiliar corner right at the heart of Ruby.
 
-## Design Principles
+## The History of Polyphony
 
 Polyphony started as an experiment, but over about two years of slow, jerky
 evolution turned into something I'm really excited to share with the Ruby
@@ -58,31 +58,24 @@ Polyphony today as nothing like the way it began. A careful examination of the
 [CHANGELOG](https://github.com/digital-fabric/polyphony/blob/master/CHANGELOG.md)
 would show how Polyphony explored not only different event reactor designs, but
 also different API designs incorporating various concurrent paradigms such as
-promises, async/await, fibers, and finally structured concurrency. 
-
-While Polyphony, like nio4r or EventMachine, uses an event reactor to turn
-blocking operations into non-blocking ones, it completely embraces fibers and in
-fact does not provide any callback-based APIs. Furthermore, Polyphony provides
-fullblown fiber-aware implementations of blocking operations, such as
-`read/write`, `sleep` or `waitpid`, instead of just event watching primitives.
+promises, async/await, fibers, and finally structured concurrency.
 
 Throughout the development process, it was my intention to create a programming
-interface that would make highly-concurrent 
-
-
-
-
+interface that would make it easy to author highly-concurrent Ruby programs.
 
+## Design Principles
 
+While Polyphony, like nio4r or EventMachine, uses an event reactor to turn
+blocking operations into non-blocking ones, it completely embraces fibers and in
+fact does not provide any callback-based APIs.
 
-a single Ruby process may spin up millions of
-concurrent fibers.
+Furthermore, Polyphony provides fullblown fiber-aware implementations of
+blocking operations, such as `read/write`, `sleep` or `waitpid`, instead of just
+event watching primitives.
 
-, by utilizing Ruby fibers together with the
-[libev](http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod) event reactor
-library. Polyphony's design is based on the following principles:
+Polyphony's design is based on the following principles:
 
-- Polyphony's concurrency model should feel "baked-in". The API should allow
+- The concurrency model should feel "baked-in". The API should allow
   concurrency with minimal effort. Polyphony should facilitate writing both
   large apps and small scripts with as little boilerplate code as possible.
   There should be no calls to initialize the event reactor, or other ceremonial
@@ -91,8 +84,8 @@ library. Polyphony's design is based on the following principles:
   ```ruby
   require 'polyphony'
 
-  # start 10 fibers, each sleeping for 1 second
-  10.times { spin { sleep 1 } }
+  # start 10 fibers, each sleeping for 3 seconds
+  10.times { spin { sleep 3 } }
 
   puts 'going to sleep now'
   # wait for other fibers to terminate
@@ -106,14 +99,14 @@ library. Polyphony's design is based on the following principles:
   ```ruby
   # in Polyphony, I/O ops might block the current fiber, but implicitly yield to
   # other concurrent fibers:
-  clients.each { |client|
+  clients.each do |client|
     spin { client.puts 'Elvis has left the chatroom' }
-  }
+  end
   ```
 
 - Concurrency primitives should be accessible using idiomatic Ruby techniques
   (blocks, method chaining...) and should feel as much as possible "part of the
-  language". The resulting API is based more on methods and less on classes,
+  language". The resulting API is fundamentally based on methods rather than classes,
   for example `spin` or `move_on_after`, leading to a coding style that is both
   more compact and more legible:
 
@@ -125,8 +118,6 @@ library. Polyphony's design is based on the following principles:
   }
   ```
 
-- Breaking up operations into 
-
 - Polyphony should embrace Ruby's standard `raise/rescue/ensure` exception
   handling mechanism. Exception handling in a highly concurrent environment
   should be robust and foolproof:
@@ -147,7 +138,8 @@ library. Polyphony's design is based on the following principles:
   constructs through composition.
 
 - The entire design should embrace fibers. There should be no callback-based
-  asynchronous APIs.
+  asynchronous APIs. The library and its ecosystem will foster the development
+  of techniques and tools for converting callback-based APIs to fiber-based ones.
 
 - Use of extensive monkey patching of Ruby core modules and classes such as
   `Kernel`, `Fiber`, `IO` and `Timeout`. This allows porting over non-Polyphony
@@ -160,13 +152,10 @@ library. Polyphony's design is based on the following principles:
   # use TCPServer from Ruby's stdlib
   server = TCPServer.open('127.0.0.1', 1234)
   while (client = server.accept)
-    spin do
+    spin {
       while (data = client.gets)
-        client.write('you said: ', data.chomp, "!\n")
+        client.write("you said: #{ data.chomp }\n")
       end
-    end
+    }
   end
   ```
-
-- Development of techniques and tools for converting callback-based APIs to
-  fiber-based ones.

data/docs/main-concepts/fiber-scheduling.md

@@ -44,7 +44,7 @@ pong = Fiber.new { loop { puts "pong"; ping.transfer } }
 ping.transfer
 ```
 
-`Fiber#transform` also allows using the main fiber as a general purpose
+`Fiber#transfer` also allows using the main fiber as a general purpose
 resumable execution context. For that reason, Polyphony uses `Fiber#transfer`
 exclusively for scheduling fibers. Normally, however, applications based on
 Polyphony will not use this API directly.

data/examples/core/xx-channels.rb

@@ -2,10 +2,12 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/core/channel'
 
 def echo(cin, cout)
   puts 'start echoer'
   while (msg = cin.receive)
+    puts "echoer received #{msg}"
     cout << "you said: #{msg}"
   end
 ensure
@@ -20,7 +22,7 @@ spin do
   puts 'start receiver'
   while (msg = chan2.receive)
     puts msg
-    $main.resume if msg =~ /world/
+    $main.schedule if msg =~ /world/
   end
 ensure
   puts 'receiver stopped'
@@ -42,4 +44,4 @@ $main = spin do
   puts "done #{Time.now - t0}"
 end
 
-suspend
+$main.await