polyphony-http 0.24

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ca781bfd155cadb774a4b9578c947aed555ad14af76d282d17be7a8f765faae
+  data.tar.gz: 4317fb42a26ca09d769d78905a89e6c12c0eb0bbc4b18b7b74ff5132a6ac90ac
+SHA512:
+  metadata.gz: 82d55c481540b596463e18fb9eea87f92e52c53e5fab04cbddeca54b4a5462002f4b58657dc0c5afc3cec763999798e564fed3a82fe234dd98fe565318602f57
+  data.tar.gz: fada33a093f8c9967a0927173c57d03d0e82c27b80de6a113e435810f2bd8d05f894dc467c66883f4196ed72702bdef0e207892ac1b233501fc96cfd8ca749d6

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+0.24 2020-01-08
+---------------
+
+* Move HTTP to separate polyphony-http gem
+
+For earlier changes look at the Polyphony changelog.

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    polyphony-http (0.24)
+      http-2 (~> 0.10.0)
+      http_parser.rb (~> 0.6.0)
+      modulation (~> 1.0)
+      polyphony (~> 0.30)
+      rack (~> 2.0.8)
+      websocket (~> 1.2.8)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.4)
+    docile (1.3.2)
+    http-2 (0.10.1)
+    http_parser.rb (0.6.0)
+    json (2.1.0)
+    localhost (1.1.4)
+    minitest (5.11.3)
+    minitest-reporters (1.4.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    modulation (1.0)
+    polyphony (0.30)
+      modulation (~> 1.0)
+    rack (2.0.9)
+    ruby-progressbar (1.10.1)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    websocket (1.2.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  localhost (~> 1.1.4)
+  minitest (~> 5.11.3)
+  minitest-reporters (~> 1.4.2)
+  polyphony-http!
+  simplecov (~> 0.17.1)
+
+BUNDLED WITH
+   2.1.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Sharon Rosner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Polyphony - Easy Concurrency for Ruby
+
+[DOCS](https://dfab.gitbook.io/polyphony) |
+[EXAMPLES](examples)
+
+> Polyphony \| pəˈlɪf\(ə\)ni \| _Music_ - the style of simultaneously combining a number of parts, each forming an individual melody and harmonizing with each other.
+
+## What is Polyphony
+
+Polyphony is a library for building concurrent applications in Ruby. Polyphony harnesses the power of [Ruby fibers](https://ruby-doc.org/core-2.5.1/Fiber.html) to provide a cooperative, sequential coprocess-based concurrency model. Under the hood, Polyphony uses [libev](https://github.com/enki/libev) as a high-performance event reactor that provides timers, I/O watchers and other asynchronous event primitives.
+
+Polyphony makes it possible to use normal Ruby built-in classes like `IO`, and `Socket` in a concurrent fashion without having to resort to threads. Polyphony takes care of context-switching automatically whenever a blocking call like `Socket#accept` or `IO#read` is issued.
+
+## Features
+
+* **Full-blown, integrated, high-performance HTTP 1 / HTTP 2 / WebSocket server
+  with TLS/SSL termination, automatic ALPN protocol selection, and body
+  streaming**.
+* Co-operative scheduling of concurrent tasks using Ruby fibers.
+* High-performance event reactor for handling I/O events and timers.
+* Natural, sequential programming style that makes it easy to reason about
+  concurrent code.
+* Abstractions and constructs for controlling the execution of concurrent code:
+  coprocesses, supervisors, cancel scopes, throttling, resource pools etc.
+* Code can use native networking classes and libraries, growing support for
+  third-party gems such as `pg` and `redis`.
+* Use stdlib classes such as `TCPServer`, `TCPSocket` and 
+* HTTP 1 / HTTP 2 client agent with persistent connections.
+* Competitive performance and scalability characteristics, in terms of both
+  throughput and memory consumption.
+
+## Prior Art
+
+Polyphony draws inspiration from the following, in no particular order:
+
+* [nio4r](https://github.com/socketry/nio4r/) and [async](https://github.com/socketry/async)
+  (Polyphony's C-extension code is largely a spinoff of
+  [nio4r's](https://github.com/socketry/nio4r/tree/master/ext))
+* [EventMachine](https://github.com/eventmachine/eventmachine)
+* [Trio](https://trio.readthedocs.io/)
+* [Erlang supervisors](http://erlang.org/doc/man/supervisor.html) (and actually,
+  Erlang in general)
+
+## Documentation
+
+The complete documentation for Polyphony could be found on the
+[Polyphony website](https://dfab.gitbook.io/polyphony).

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/clean"
+
+# frozen_string_literal: true
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("gyro_ext") do |ext|
+  ext.ext_dir = "ext/gyro"
+end
+
+task :default => [:compile, :test]
+task :test do
+  exec 'ruby test/run.rb'
+end
+
+task default: %w[compile]
+
+CLEAN.include "**/*.o", "**/*.so", "**/*.bundle", "**/*.jar", "pkg", "tmp"

data/TODO.md

@@ -0,0 +1,59 @@
+# HTTP Client Agent
+
+The concurrency model and the fact that we want to serve the response object on
+receiving headers and let the user lazily read the response body, means we'll
+need to change the API to accept a block:
+
+```ruby
+# current API
+resp = Agent.get('http://acme.org')
+puts resp.body
+
+# proposed API
+Agent.get('http://acme.org') do |resp|
+  puts resp.body
+end
+```
+
+While the block is running, the connection adapter is acquired. Once the block
+is done running, the request (and response) can be discarded. The problem with
+that if we spin up a coprocess from that block we risk all kinds of race
+conditions and weird behaviours.
+
+A compromise might be to allow the two: doing a `get` without providing a block
+will return a response object that already has the body (i.e. the entire
+response has already been received). Doing a `get` with a block will invoke the
+block once headers are received, letting the user's code stream the body:
+
+```ruby
+def request(ctx, &block)
+  ...
+  connection_manager.acquire do |adapter|
+    response = adapter.request(ctx)
+    if block
+      block.(response)
+    else
+      # wait for body
+      response.body
+    end
+    response
+  end
+end
+```
+
+# Roadmap:
+
+## 0.25 Full Rack adapter implementation
+
+- Work better mechanism supervising multiple coprocesses (`when_done` feels a
+  bit hacky)
+- Add supervisor test
+- Homogenize HTTP 1 and HTTP 2 headers - upcase ? downcase ?
+- find some demo Rack apps and test with Polyphony
+
+## 0.26 Working Sinatra application
+
+- app with database access (postgresql)
+- benchmarks!
+
+## 0.27 Testing & docs

data/bin/poly

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require_relative('../lib/polyphony/http')
+
+app_path = ARGV.first || './config.ru'
+app = Polyphony::HTTP::Rack.load(app_path)
+opts = { reuse_addr: true, dont_linger: true }
+
+puts "listening on port 1234"
+puts "pid: #{Process.pid}"
+Polyphony::HTTP::Server.serve('0.0.0.0', 1234, opts, &app)

data/docs/README.md

@@ -0,0 +1,38 @@
+# Polyphony - Easy Concurrency for Ruby
+
+> Polyphony \| pəˈlɪf\(ə\)ni \|
+> 1. _Music_ the style of simultaneously combining a number of parts, each forming an individual melody and harmonizing with each other.
+> 2. _Programming_ a Ruby gem for concurrent programming focusing on performance and developer happiness.
+
+Polyphony is a library for building concurrent applications in Ruby. Polyphony harnesses the power of [Ruby fibers](https://ruby-doc.org/core-2.5.1/Fiber.html) to provide a cooperative, sequential coprocess-based concurrency model. Under the hood, Polyphony uses [libev](https://github.com/enki/libev) as a high-performance event reactor that provides timers, I/O watchers and other asynchronous event primitives.
+
+Polyphony makes it possible to use normal Ruby built-in classes like `IO`, and `Socket` in a concurrent fashion without having to resort to threads. Polyphony takes care of context-switching automatically whenever a blocking call like `Socket#accept` or `IO#read` is issued.
+
+## Features
+
+* **Full-blown, integrated, high-performance HTTP 1 / HTTP 2 / WebSocket server with TLS/SSL termination, automatic ALPN protocol selection, and body streaming**.
+* Co-operative scheduling of concurrent tasks using Ruby fibers.
+* High-performance event reactor for handling I/O events and timers.
+* Natural, sequential programming style that makes it easy to reason about concurrent code.
+* Abstractions and constructs for controlling the execution of concurrent code: coprocesses, supervisors, cancel scopes, throttling, resource pools etc.
+* Code can use native networking classes and libraries, growing support for third-party gems such as `pg` and `redis`.
+* Use stdlib classes such as `TCPServer` and `TCPSocket` and `Net::HTTP`.
+* HTTP 1 / HTTP 2 client agent with persistent connections.
+* Competitive performance and scalability characteristics, in terms of both throughput and memory consumption.
+
+## Prior Art
+
+Polyphony draws inspiration from the following, in no particular order:
+
+* [nio4r](https://github.com/socketry/nio4r/) and [async](https://github.com/socketry/async) (Polyphony's C-extension code is largely a spinoff of [nio4r's](https://github.com/socketry/nio4r/tree/master/ext))
+* [EventMachine](https://github.com/eventmachine/eventmachine)
+* [Trio](https://trio.readthedocs.io/)
+* [Erlang supervisors](http://erlang.org/doc/man/supervisor.html) (and actually, Erlang in general)
+
+## Going further
+
+To learn more about using Polyphony to build concurrent applications, read the technical overview below, or look at the [included examples](https://github.com/digital-fabric/polyphony/tree/9e0f3b09213156bdf376ef33684ef267517f06e8/examples/README.md). A thorough reference is forthcoming.
+
+## Contributing to Polyphony
+
+Issues and pull requests will be gladly accepted. Please use the git repository at https://github.com/digital-fabric/polyphony as your primary point of departure for contributing.

data/docs/summary.md

@@ -0,0 +1,60 @@
+# Table of contents
+
+* [Polyphony - Easy Concurrency for Ruby](../README.md)
+
+## Getting Started
+
+* [Installing](getting-started/installing.md)
+* [Tutorial](getting-started/tutorial.md)
+
+## Technical overview
+
+* [Design Principles](technical-overview/design-principles.md)
+* [Concurrency the Easy Way](technical-overview/concurrency.md)
+* [How Fibers are Scheduled](technical-overview/fiber-scheduling.md)
+* [Exception Handling](technical-overview/exception-handling.md)
+* [Frequently Asked Questions](technical-overview/faq.md)
+
+## How To
+
+* [Make an echo server](howto/echo-server.md)
+* [Make an HTTP server](howto/http-server.md)
+* [Make a Websocket server](howto/websocket-server.md)
+* [Use timers](howto/timers.md)
+* [Throttle recurrent operations](howto/throttle.md)
+* [Cancel ongoing operations](howto/cancel.md)
+* [Control coprocesses](howto/coprocesses.md)
+* [Synchronize concurrent operations](howto/synchronize.md)
+* [Perform CPU-bound operations](howto/cpu-bound.md)
+* [Control backpressure](howto/backpressure.md)
+* [Fork worker processes](howto/worker-processes.md)
+
+## Polyphony extensions
+
+* [Postgresql](extensions/pg)
+* [Redis](extensions/redis)
+* [IRB](extensions/irb)
+* [Throttlers](#)
+* [Resource Pools](#)
+* [Synchronisation](#)
+* [Web Server](user-guide/web-server.md)
+* [Websocket Server](#)
+* [Reactor API](#)
+
+## API Reference
+
+* [Polyphony::CancelScope](#)
+* [Polyphony::Coprocess](#)
+* [Gyro](#)
+* [Gyro::Async](#)
+* [Gyro::Child](#)
+* [Gyro::IO](#)
+* [Gyro::Timer](#)
+* [Kernel](#)
+* [Polyphony](#)
+* [Polyphony::Mutex](#)
+* [Polyphony::Pulser](#)
+* [Polyphony::ResourcePool](#)
+* [Polyphony::Throttler](#)
+
+## [Contributing to Polyphony](contributing.md)

data/examples/cuba.ru

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'cuba'
+require 'cuba/safe'
+
+Cuba.use Rack::Session::Cookie, secret: '__a_very_long_string__'
+
+Cuba.plugin Cuba::Safe
+
+Cuba.define do
+  on get do
+    on 'hello' do
+      res.write 'Hello world!'
+    end
+
+    on root do
+      res.redirect '/hello'
+    end
+  end
+end
+
+run Cuba

data/examples/happy_eyeballs.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# idea taken from the example given in trio:
+# https://www.youtube.com/watch?v=oLkfnc_UMcE
+
+require 'bundler/setup'
+require 'polyphony/http'
+
+def try_connect(target, supervisor)
+  puts "trying #{target[2]}"
+  socket = Polyphony::Net.tcp_connect(target[2], 80)
+  # connection successful
+  supervisor.stop!([target[2], socket])
+rescue IOError, SystemCallError
+  # ignore error
+end
+
+def happy_eyeballs(hostname, port, max_wait_time: 0.025)
+  targets = Socket.getaddrinfo(hostname, port, :INET, :STREAM)
+  t0 = Time.now
+  cancel_after(5) do
+    success = supervise do |supervisor|
+      targets.each_with_index do |t, idx|
+        sleep(max_wait_time) if idx > 0
+        supervisor.spin { try_connect(t, supervisor) }
+      end
+    end
+    if success
+      puts format('success: %s (%.3fs)', success[0], Time.now - t0)
+    else
+      puts "timed out (#{Time.now - t0}s)"
+    end
+  end
+end
+
+# Let's try it out:
+happy_eyeballs('debian.org', 'https')