tipi 0.30

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 92c33ccc40f7b8f4f53fded65ab5902c81bcf0a92598fa5b2be3ada409a78721
+  data.tar.gz: b4f80d28c10539b44d1554fbd8e640c253919070cc576efbf62249eee8efeeb7
+SHA512:
+  metadata.gz: 6a5712289bb6adc18e4c6fa24495157c19c41831036adc2e5ef082a640b09df426d015de5f00cb48d1d78d0855ce078c1cc7f2c15a1cec24a68cf022d45f9eea
+  data.tar.gz: 55e627cb9a6e91a846460ee30f3480ad77e4cb9124a40cd2fc68bf9abba7d6ecdbc52530ac92271d78c4a75fc9654be706efb59dba491ebbc6bc70532bc42aaa

data/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Tests
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest]
+        ruby: [2.6, 2.7]
+
+    name: >-
+      ${{matrix.os}}, ${{matrix.ruby}}
+
+    runs-on: ${{matrix.os}}
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+    - name: Install dependencies
+      run: |
+        gem install bundler
+        bundle install
+    - name: Run tests
+      run:  bundle exec rake test

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,33 @@
+## 0.30 2020-07-15
+
+* Rename project to Tipi
+* Rearrange source code
+* Remove HTTP client code (to be developed eventually into a separate gem)
+* Fix header rendering in rack adapter (#2)
+
+## 0.29 2020-07-06
+
+* Use IO#read_loop
+
+## 0.28 2020-07-03
+
+* Update with API changes from Polyphony >= 0.41
+
+## 0.27 2020-04-14
+
+* Remove modulation dependency
+
+## 0.26 2020-03-03
+
+* Fix `Server#listen`
+
+## 0.25 2020-02-19
+
+* Ensure server socket is closed upon stopping loop
+* Fix `Request#format_header_lines`
+
+## 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,50 @@
+PATH
+  remote: .
+  specs:
+    tipi (0.30)
+      http-2 (~> 0.10.0)
+      http_parser.rb (~> 0.6.0)
+      polyphony (~> 0.43.5)
+      rack (>= 2.0.8, < 2.3.0)
+      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.2)
+    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
+    polyphony (0.43.5)
+    rack (2.2.3)
+    rake (12.3.3)
+    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)
+  rake (~> 12.3.3)
+  simplecov (~> 0.17.1)
+  tipi!
+
+BUNDLED WITH
+   2.1.4

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,23 @@
+# Tipi - the All-in-one Web Server for Ruby Apps
+
+[![Gem Version](https://badge.fury.io/rb/tipi.svg)](http://rubygems.org/gems/tipi)
+[![Modulation Test](https://github.com/digital-fabric/tipi/workflows/Tests/badge.svg)](https://github.com/digital-fabric/tipi/actions?query=workflow%3ATests)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/tipi/blob/master/LICENSE)
+
+## What is Tipi?
+
+Tipi is an integrated, feature-complete HTTP/S server for Ruby applications.
+Tipi is built on Polyphony, a robust, high-performance library for building
+highly-concurrent applications in Ruby. Tipi can be used to serve any Rack
+application or set of static files directly without having to employ a
+reverse-proxy such as Nginx.
+
+## Features
+
+* **Full-blown, integrated, high-performance HTTP 1 / HTTP 2 / WebSocket server
+  with TLS/SSL termination, automatic ALPN protocol selection, and body
+  streaming**.
+
+## Documentation
+
+Documentation for Tipi is coming soon...

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/clean"
+
+# frozen_string_literal: true
+
+task :default => [:test]
+task :test do
+  exec 'ruby test/run.rb'
+end
+

data/TODO.md

@@ -0,0 +1,66 @@
+# Roadmap
+
+- Update README (get rid of non-http stuff)
+- Improve Rack spec compliance, add tests
+- Homogenize HTTP 1 and HTTP 2 headers - upcase ? downcase ?
+
+## 0.30
+
+- Add more poly CLI commands and options:
+
+  - serve static files from given directory
+  - serve from rack up file
+  - serve both http and https
+  - use custom certificate files for SSL
+  - set host address to bind to
+  - set port to bind to
+  - set forking process count
+
+## 0.31 Working Sinatra application
+
+- app with database access (postgresql)
+- benchmarks!
+
+# 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
+```
+

data/bin/tipi

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require File.expand_path('../lib/tipi', __dir__)
+require File.expand_path('../lib/tipi/rack_adapter', __dir__)
+
+app_path = ARGV.first || './config.ru'
+app = Tipi::RackAdapter.load(app_path)
+opts = { reuse_addr: true, dont_linger: true }
+
+puts "listening on port 1234"
+puts "pid: #{Process.pid}"
+Tipi.serve('0.0.0.0', 1234, opts, &app)

data/docs/README.md

@@ -0,0 +1,62 @@
+# 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, 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)