midori.rb 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4b10de10fd9f845940ff8facc3b9442d68375a14
-  data.tar.gz: 90389f69f41d8cf55650a108b580a98b7a808ea5
+SHA256:
+  metadata.gz: 0ffac6eac2b627e157f087d6c92d6e7e52f0e76af114a8a575e2e0fef512d388
+  data.tar.gz: 48c09ef3b224fc67f74a3eead572bf729b9110643b0f837c1034147c57eddada
 SHA512:
-  metadata.gz: 73cbcdb722891971a8e8ac238d8e0084ffc3000fa57efdf5e106df6c4d729b3fa99eadf7b0f5fa9ad03a746ed6eb5e95f1ba0cd11b61cd098ccacbb0ec1c3505
-  data.tar.gz: de462c5564b2bba6ef7c36f737d8291fef6e757d294dd100ee653ef5c3b55223d7c35003e1ddef4ce883fd242a948dcfd2bb208c5f78e7e663ba3879c1ce71de
+  metadata.gz: faccb4442498bf24e101933af5b7f46c9c4f6ecf5c6f2a3fe912254b3171b3c0e8ebec73b41dc10916250aeca8e36ef5cc78e58b33e3860d8812e5b4616cc3de
+  data.tar.gz: 68b22b8a8a053546a1131ac67cb7201b60856d7f2012519d19e8ee40766788954079782cc4dea96233c3ba7df6fd23111f5c90b41b800f3319bac70644264151

data/lib/midori/configure.rb

@@ -13,4 +13,5 @@ class Midori::Configure
   set :trust_real_ip, false
   set :trusted_proxies, /\A127\.0\.0\.1\Z|\A(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.|
                          \A::1\Z|\Afd[0-9a-f]{2}:.+|\Alocalhost\Z|\Aunix\Z|\Aunix:/ix
+  set :tcp_fast_open, true
 end

data/lib/midori/core_ext/tcp_server.rb

@@ -0,0 +1,11 @@
+class TCPServer
+  def tcp_fast_open
+    # macOS devices option is DIFFERENT from Linux and FreeBSD
+    opt = (/darwin/ =~ RUBY_PLATFORM) ? 1 : 5
+    # Magic number 6 may refer to Socket::SOL_TCP or Socket::IPPROTO_TCP
+    self.setsockopt(6, Socket::TCP_FASTOPEN, opt)
+    true
+  rescue => _e
+    false
+  end
+end

data/lib/midori/runner.rb

@@ -31,6 +31,8 @@ class Midori::Runner
     return false if running? || EventLoop.running?
     @logger.info "Midori #{Midori::VERSION} is now running on #{bind}:#{port}".blue
     @server = TCPServer.new(@bind, @port)
+    tfo = @server.tcp_fast_open if Midori::Configure.tcp_fast_open
+    @logger.warn 'Failed to use TCP Fast Open feature on your OS'.yellow unless tfo
     EventLoop.register(@server, :r) do |monitor|
       socket = monitor.io.accept_nonblock
       connection = Midori::Connection.new(socket)

data/lib/midori/server.rb

@@ -39,6 +39,9 @@ module Midori::Server
             @request.parse(data)
             receive_new_request if @request.parsed && @request.body_parsed?
           end
+        rescue EOFError, Errno::ENOTCONN => _e
+          close_connection
+          # Ignore client's disconnection
         rescue => e
           close_connection
           @logger.warn "#{@request.ip} - - #{e.class} #{e.backtrace.join("\n")}".yellow

data/lib/midori/version.rb

@@ -1,5 +1,5 @@
 # Midori Module
 module Midori
   # Current Version Code
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.5.1'.freeze
 end

data/lib/midori.rb

@@ -10,10 +10,11 @@ require 'socket'
 
 require_relative 'midori_ext'
 require_relative 'midori/core_ext/configurable'
-require_relative 'midori/core_ext/http_header'
-require_relative 'midori/core_ext/string'
 require_relative 'midori/core_ext/define_class'
+require_relative 'midori/core_ext/http_header'
 require_relative 'midori/core_ext/proc'
+require_relative 'midori/core_ext/string'
+require_relative 'midori/core_ext/tcp_server'
 
 require_relative 'midori/version'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midori.rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - HeckPsi Lab
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-26 00:00:00.000000000 Z
+date: 2018-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: murasaki
@@ -91,6 +91,7 @@ files:
 - lib/midori/core_ext/http_header.rb
 - lib/midori/core_ext/proc.rb
 - lib/midori/core_ext/string.rb
+- lib/midori/core_ext/tcp_server.rb
 - lib/midori/env.rb
 - lib/midori/eventsource.rb
 - lib/midori/exception.rb
@@ -105,24 +106,6 @@ files:
 - lib/midori/version.rb
 - lib/midori/websocket.rb
 - midori.sublime-project
-- tutorial/README.md
-- tutorial/SUMMARY.md
-- tutorial/advanced/custom_extensions.md
-- tutorial/advanced/deploying_for_production.md
-- tutorial/advanced/error_handling.md
-- tutorial/advanced/rerl.md
-- tutorial/advanced/scaling_project.md
-- tutorial/advanced/unit_testing.md
-- tutorial/essentials/extensions.md
-- tutorial/essentials/getting_started.md
-- tutorial/essentials/installation.md
-- tutorial/essentials/middlewares.md
-- tutorial/essentials/request_handling.md
-- tutorial/essentials/routing.md
-- tutorial/essentials/runner.md
-- tutorial/meta/comparison_with_other_frameworks.md
-- tutorial/meta/join_the_midori_community.md
-- tutorial/meta/next_steps.md
 homepage: https://github.com/midori-rb/midori.rb
 licenses:
 - MIT
@@ -149,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: High performance ruby web framework

data/tutorial/README.md

@@ -1,11 +0,0 @@
-# Introduction
-
-## What is midori?
-
-Midori (pronounced /miːdɒliː/) is a **Ruby web framework** for building APIs, web pages and realtime web services. Midori is designed to provide **non-blocking** I/O operations without **callback hells** on web development. The core library is focused on network I/Os, and gives a very easy DSL to pick up and converting existed projects on. On the other hand, midori also officially provides extension libraries that could deal with file, database, cache, network requests and other I/O operations without blocking.
-
-If you want to know how midori compares to other libraries/frameworks, checkout out the [Comparison with Other Frameworks](meta/comparison_with_other_frameworks.md)
-
-## Note
-
-The official guide assumes intermediate level knowledge of Ruby and backend development. If you are totally new , it might not be the best idea to jump right into a framework as your first step - grasp the basics then come back! Prior experience with other frameworks like Rails helps, but is not required.

data/tutorial/SUMMARY.md

@@ -1,29 +0,0 @@
-# Summary
-
-## Essentials
-
-* [Introduction](README.md)
-* [Installation](essentials/installation.md)
-* [Getting Started](essentials/getting_started.md)
-* [Routing](essentials/routing.md)
-* [Request Handling](essentials/request_handling.md)
-* [Runner](essentials/runner.md)
-* [Middlewares](essentials/middlewares.md)
-* [Extensions](essentials/extensions.md)
-
-
-## Advanced
-
-- [Error Handling](advanced/error_handling.md)
-- [Request-Eval-Response Loop](advanced/rerl.md)
-- [Custom Extensions](advanced/custom_extensions.md)
-- [Scaling Project](advanced/scaling_project.md)
-- [Unit Testing](advanced/unit_testing.md)
-- [Deploying for Production](advanced/deploying_for_production.md)
-
-## Meta
-
-- [Comparison with Other Frameworks](meta/comparison_with_other_frameworks.md)
-- [Next Steps](meta/next_steps.md)
-- [Join the Midori Community](meta/join_the_midori_community.md)
-

data/tutorial/essentials/extensions.md

@@ -1,31 +0,0 @@
-# Extensions
-
-Extensions are rubygems that could combine other gems with midori through meta-programming.
-There's a set of officially supported midori extensions called `midori-contrib`.
-This contains gems commonly used like Database ORM, Redis Driver, Redis ORM, HTTP Driver, etc.
-
-To include it inside your project, be sure to get the original gem installed without require it.
-Then include specific parts of `midori-contrib` to make it work.
-
-For example:
-
-`Gemfile`
-
-```ruby
-source 'https://rubygems.org'
-
-gem 'bundler', '~> 1.0'
-gem 'rake', '~> 12.0'
-
-gem 'hiredis', '~> 0.6.0', require: false
-gem 'ohm', '~> 3.0'
-gem 'sequel', '~> 5.0', require: false
-gem 'mysql2', '~> 0.4', require: false
-
-gem 'em-midori', '~> 0.4.3', require: 'midori'
-gem 'midori-contrib', '~> 0.1.0', require: %w(
-    midori-contrib
-    midori-contrib/sequel/mysql2
-    midori-contrib/redic
-  )
-```

data/tutorial/essentials/getting_started.md

@@ -1,27 +0,0 @@
-# Getting Started
-
-## Hello Midori
-
-midori is a [DSL](https://en.wikipedia.org/wiki/Domain-specific_language) for web and API development in Ruby  with minimal effort:
-
-```ruby
-# hello_midori.rb
-require 'midori'
-
-class HelloWorldAPI < Midori::API
-  get '/' do
-    'Ohayou Midori'
-  end
-end
-
-Midori::Runner.new(HelloWorldAPI).start
-```
-
-Run with
-
-```
-$ ruby hello_midori.rb
-```
-
-View at: http://127.0.0.1:8080 with your browser, if you see a page showing: **Ohayou Midori**. You've made your first application with midori.
-

data/tutorial/essentials/installation.md

@@ -1,93 +0,0 @@
-# Installation
-
-## Requirements
-
-Open up a command line prompt. Any commands prefaced with a dollar sign `$` should be run in the command line. Verify that you have a current version of Ruby installed:
-
-```
- $ ruby -v
- ruby 2.4.1p111
-```
-
-Generally, midori supports the following ruby interpreters:
-
-- Ruby (MRI) **>= 2.2.6**
-
- For every version released, it would be tested and **officially ensured** in the following environments:
-
-- Ruby (MRI)
-  - 2.2.8
-  - 2.3.5
-  - 2.4.2
-
-**Note: **
-
-- **For JRuby users, due to some C extensions used in midori, it is still unable to run on the current version of JRuby.**
-- **For macOS users, you may meet performance problem due to the issue of [nio4r](https://github.com/socketry/nio4r/issues/125). Very few people would use macOS in production, so this issue may not affect much. We would still be working hard on fixing it, but the issue wouldn't be a high priority one.**
-
-It's hard to say that if it is possible for running on other ruby implementations like Rubinius or RubyMotion, if you're in favor of supporting more ruby implementations, you could open a ticket [here](https://github.com/midori-rb/midori.rb/issues), and we are glad to discuss it.
-
-## Install with RubyGems
-
-```
-$ gem install em-midori
-Successfully installed em-midori-0.4.3
-1 gem installed
-```
-
-To test whether it has installed properly, run:
-
-```
-$ ruby -r "midori" -e "class A < Midori::API;end;Midori::Runner.new(A).start"
-```
-
-If you see the following message, then everything now works fine.
-
-```
-Midori 0.4.3 is now running on 127.0.0.1:8080
-```
-
-## Use Bundler
-
-Example `Gemfile` of basic usage as following:
-
-```ruby
-source 'https://rubygems.org'
-gem 'bundler', '~> 1.0'
-gem 'em-midori', '~> 0.4', require: 'midori'
-```
-
-and then running:
-
-```
-$ bundle install
-```
-
-You could use
-
-```ruby
-require 'bundler'
-Bundler.require
-```
-
-in your entrance ruby file.
-
-To include built-in extensions of midori you could make your `Gemfile` like:
-
-```ruby
-source 'https://rubygems.org'
-gem 'bundler', '~> 1.0'
-gem 'em-midori', '~> 0.4', require: 'midori'
-gem 'midori-contrib', '~> 0.0.1', require: %w'midori-contrib/file midori-contrib/sequel/mysql2'
-```
-
-Using bunlder could make dependency management much easier, which helps a lot in scaling project. To learn more about bundler, you could see docs [here](http://bundler.io/docs.html). 
-
-## For Developers in China
-
-You may probably meet problems with rubygems due to unstable overseas internet connection issues in China. The most popular way to solve it is to use mirror provided by [RubyChina](https://gems.ruby-china.org/) or [TUNA](https://mirror.tuna.tsinghua.edu.cn/help/rubygems/) as your gem source. This may have some side effects in development, because there's a few minutes' delay in receiving gem updates.
-
-Alternatively, you could use proxy to connect to the main repository directly to avoid the delay problem. But using proxy is a little too complex in production environment.
-
-Choose the solution better fits your requirements. Mixing the solutions like using proxy in development and using mirror in production is also a good choice.
-

data/tutorial/essentials/middlewares.md

@@ -1,88 +0,0 @@
-# Middlewares
-
-Middlewares are very exciting features midori support.
-As it has been implemented for lots of web frameworks.
-Middlewares from midori behaves very different from other frameworks, which greatly helps reducing complexity and improving performance in scaling projects.
-
-## Basic Usage
-
-To begin with, inheritate the `Midori::Middleware` class. Here's an example:
-
-```ruby
-class JSONMiddleware < Midori::Middleware
-  def before(request)
-    request.body = JSON.parse(request.body) unless request.body == ''
-    request
-  end
-
-  def after(_request, response)
-    response.header['Content-Type'] = 'application/json'
-    response.body = response.body.to_json
-    response
-  end
-end
-```
-
-To use middleware inside router, there're two possible ways.
-One is through `use` method, which would affect all routes in the current scope.
-The other is through `filter` method, which would affect the following route definition only.
-
-Here are some examples.
-
-```ruby
-class API < Midori::API
-  use AMiddleware
-
-  filter BMiddleware
-  get '/' do
-    # Both AMiddleware and BMiddleware works here.
-    'Hello'
-  end
-
-  get '/a' do
-    # Only AMiddleware is involved here.
-    'World'
-  end
-end
-```
-
-## Stack-less Design
-
-For rack users, middlewares are always considered as parts of stack.
-Deep stacks may cause several performance issues in Ruby, including increasing cost when context switching, thread switching and process forking, etc.
-For frameworks like Rails, it defaulty contains lots of middlewares which enlarge this problem.
-
-In midori, middlewares are no longer stack-based.
-It uses a loop-based system to run middleware code.
-This makes using of middlewares with less side effects.
-
-## Early Exit Feature
-
-Early exit feature is also supported in midori without stack.
-To make it happen, just respond an `Midori::Response` object during request processing.
-Here's an example for CORS middleware using early exit feature.
-
-```ruby
-class CorsMiddleware < Midori::Middleware
-  def before(request)
-    if request.method == :OPTIONS
-      # PREFLIGHT
-      return Midori::Response.new(
-        header: {
-          'Access-Control-Allow-Origin': request.header['Origin'],
-          'Access-Control-Request-Headers': 'Token',
-          'Access-Control-Allow-Headers': 'Token',
-          'Access-Control-Allow-Methods': 'OPTIONS, POST, PUT, DELETE'
-        }
-      )
-    else
-      request
-    end
-  end
-
-  def after(request, response)
-    response.header['Access-Control-Allow-Origin'] = request.header['Origin']
-    response
-  end
-end
-```

data/tutorial/essentials/request_handling.md

@@ -1,74 +0,0 @@
-# Request Handling
-
-## Accessing the request object
-
-The incoming request object can be accessed from request level (filter, routes, error handlers) through the `request` method:
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/' do
-    request.ip           # '127.0.0.1' client ip address
-    request.port         # '8080' client port
-    request.method       # 'GET'
-    request.path         # '/'
-    request.query_string # ''
-    request.query_params # {} query params, parsed from query string
-    request.header       # {} request header
-    request.body         # request body sent by the client
-    request.params       # {} params matched in router
-    request.cookie       # {} cookie parsed from header
-  end
-end
-```
-
-**Note (for sinatra users): **The `request.body` in modori is a `String` object but not a `StringIO` object.
-
-## Construct the response object
-
-Midori accepts the return value of the block as the response body by default.
-
-You could edit variable `status` and `header` to construct things other than body.
-
-You could also return a `Midori::Response` object as your response, which could override everything.
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/case_0' do
-    'Hello'
-    # HTTP/1.1 200 OK
-    # Server: Midori/1.0
-    #
-    # Hello
-  end
-  
-  get '/case_1' do
-    @status = 418
-    "I\'m a teapot"
-    # HTTP/1.1 418 I'm a teapot
-    # Server: Midori/1.0
-    #
-    # I'm a teapot
-  end
-  
-  get '/case_2' do
-    @header['Example-Header'] = 'Example-Value'
-    'Hello'
-    # HTTP/1.1 200 OK
-    # Server: Midori/1.0
-    # Example-Header: Example-Value
-    #
-    # Hello
-  end
-  
-  get '/case_3' do
-    @status = 202
-    @header['Example-Header'] = 'Example-Value'
-    Midori::Response.new(status: 200, header: {}, body: 'Hello') # Overrides everything else
-    # HTTP/1.1 200 OK
-    # Server: Midori/1.0
-    #
-    # Hello
-  end
-end
-```
-

data/tutorial/essentials/routing.md

@@ -1,136 +0,0 @@
-# Routing
-
-## Basic Usage
-
-Routes should be defined inside a class inherited from `Midori::API`. Midori doesn't support defining routes globally like sinatra to avoid scope pollution, which affects a lot in scaling project.
-
-In midori, a route is an HTTP method with a URL-matching pattern. Each route is associated with a block:
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/' do
-    #.. show something ..
-  end
-  
-  post '/' do
-    #.. create something ..
-  end
-  
-  put '/' do
-    #.. replace something ..
-  end
-  
-  delete '/' do
-    #.. annihilate something ..
-  end
-  
-  options '/' do
-    #.. appease something ..
-  end
-  
-  link '/' do
-    #.. affiliate something ..
-  end
-  
-  unlink '/' do
-    #.. separate something ..
-  end
-end
-```
-
-Routes are matched in the order they are defined. The first route that matches the request is invoked.
-
-Midori not only supports the methods above, it supports almost every method provided in RFC standards. You could look it up in [API doc](http://www.rubydoc.info/gems/em-midori/Midori/API) for more details.
-
-## Params
-
-Routes patterns may include named parameters, accessible via the `request.params` hash:
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/hello/:name' do
-    "Ohayou #{request.params['name']}"
-  end
-end
-```
-
-Route patterns may also include splat (or wildcard) parameters, accessible via the `request.params['splat']` array:
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/say/*/to/*' do
-    # matches /say/hello/to/world
-    request.params['splat'] # => ["hello", "world"]
-  end
-
-  get '/download/*.*' do
-    # matches /download/path/to/file.xml
-    request.params['splat'] # => ["path/to/file", "xml"]
-  end
-end
-```
-
-Routes may also utilize query string:
-
-```ruby
-class ExampleAPI < Midori::API
-  get '/posts' do
-    # matches "GET /posts?title=foo&author=bar"
-    request.query_string # => title=foo&author=bar
-  end
-end
-```
-
-## WebSocket & EventSource
-
-`WebSocket` connection uses `GET` method in HTTP protocol, but indeed, it behaves totally different from `GET` requests. You don't need to care about the protocol details. In midori, you could easily manage websocket connections easily.
-
-Here's a chatroom example using websocket in midori:
-
-```ruby
-CONNECTION_POOL = []
-
-class ExampleAPI < Midori::API
-  websocket '/' do |ws|
-    ws.on :open do
-      ws.send 'Ohayo Midori'
-      CONNECTION_POOL << ws
-    end
-    
-    ws.on :message do |msg|
-      CONNECTION_POOL.map do |client|
-        client.send msg
-      end
-    end
-    
-    ws.on :close do
-      CONNECTION_POOL.delete(ws)
-      puts 'Oyasumi midori'
-    end
-  end
-end
-```
-
-midori also supports `EventSource` connection as part of your route.
-
-Here's a chatroom example using eventsource in midori:
-
-```ruby
-CONNECTION_POOL = []
-
-class ExampleAPI < Midori::API
-  post '/pub' do
-    clients = CONNECTION_POOL.clone
-    CONNECTION_POOL.clear
-    # EventSource connection disconnects every time message sent, DO NOT reuse connection pool
-    clients.map do |client|
-      client.send request.body
-    end
-  end
-  
-  eventsource '/sub' do |es|
-    CONNECTION_POOL << es
-  end
-end
-```
-

data/tutorial/essentials/runner.md

@@ -1,59 +0,0 @@
-# Runner
-
-## Introdution
-
-`Runner` is the container of midori server. You could create, start, stop midori instance by `Runner`.
-
-`Runner` use `Midori::Configure` as its configuration by default.
-
-## Examples
-
-Here're some examples for common usages
-
-### Port Binding
-
-Start midori instance with port `4567` instead of the default `8080`.
-
-```ruby
-require 'midori'
-class API < Midori::API
-  get '/' do
-    'Hello World'
-  end
-end
-
-Midori::Configure.set :port, 4567
-Midori::Runner.new(API).start
-```
-
-### Address Binding
-
-Start midori instance listening to all IP addresses.
-
-```ruby
-require 'midori'
-class API < Midori::API
-  get '/' do
-    'Hello World'
-  end
-end
-
-Midori::Configure.set :bind, '0.0.0.0'
-Midori::Runner.new(API).start
-```
-
-### Stop Midori
-
-Stop midori instance when specified route been called.
-
-```ruby
-require 'midori'
-$runner = nil
-class API < Midori::API
-  get '/stop' do
-    $runner.stop
-  end
-end
-
-$runner = Midori::Runner.new(API).start
-```