rubycut-sinatra-synchrony 0.4.2

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,25 @@
+Copyright 2012 Kyle Drake. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY GEOLOQI ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GEOLOQI OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those of the
+authors and should not be interpreted as representing official policies, either expressed
+or implied, of Kyle Drake.

data/README.md

@@ -0,0 +1,133 @@
+Sinatra::Synchrony [![](https://secure.travis-ci.org/kyledrake/sinatra-synchrony.png)](http://travis-ci.org/kyledrake/sinatra-synchrony)
+===
+
+Sinatra + EM-Synchrony - fast, concurrent web applications with no callbacks!
+
+Sinatra::Synchrony is a very small extension for Sinatra that dramatically improves the concurrency of your web application. Powered by [EventMachine](https://github.com/eventmachine/eventmachine) and [EM-Synchrony](https://github.com/igrigorik/em-synchrony), it increases the number of clients your application can serve per process when you have a lot of slow IO calls (like HTTP calls to external APIs). Because it uses [Fibers](http://www.ruby-doc.org/core-1.9/classes/Fiber.html) internally to handle concurrency, no callback gymnastics are required! Just develop as if you were writing a normal Sinatra web application, use non-blocking libraries (see below) and you're all set!
+
+How it works
+---
+
+* Loads [EventMachine](https://github.com/eventmachine/eventmachine) and [EM-Synchrony](https://github.com/igrigorik/em-synchrony). Requires app server with EventMachine and Ruby 1.9 support (Thin, Rainbows!, Heroku). It should also work on JRuby (with JRUBY_OPTS="--1.9").
+* Inserts the [Rack::FiberPool](https://github.com/mperham/rack-fiber_pool) middleware, which automatically provides a Fiber for each incoming request, allowing EM-Synchrony to work.
+* Adds [em-http-request](https://github.com/igrigorik/em-http-request), which you can use with EM::Synchrony to do concurrent HTTP calls to APIs! Or if you'd rather use a different client:
+* Patches TCPSocket via EM-Synchrony. Any software that uses this (such as an HTTP Client that uses Net::HTTP) can run without blocking IO. [RestClient](https://github.com/archiloque/rest-client) works great with this!
+* Patches Rack::Test so that it runs your tests within an EventMachine. Just test the same way you did before and it should just work.
+* Patches Resolv via [em-resolv-replace](https://github.com/mperham/em-resolv-replace), enabling non-blocking DNS lookups magically, the way David Bowie would want it.
+
+What it doesn't do (yet)
+---
+
+Provide non-blocking drivers for everything. Right now the focus was to deal with the biggest concurrency problem for most apps, which is API calls to external websites. You don't have to make _everything_ non-blocking to speed up applications with this approach, which is the important thing to understand. For example, if your database access is under ten milliseconds, it's not as bad as an API call to an external web site that takes a few seconds. There are numerous non-blocking drivers available however, check out the [Protocol Implementations](https://github.com/eventmachine/eventmachine/wiki/Protocol-Implementations) page on the [EventMachine GitHub Wiki](https://github.com/eventmachine/eventmachine/wiki) for a full list. I would personally like to see plug-and-play drivers implemented for the major three ORMs (ActiveRecord, DataMapper, Sequel), because then I could simply drop them into this gem and you'd be non-blocking without requiring any special changes. For most of the web applications I work on, this would be all I need to eliminate my blocking IO problems forever!
+
+Installation
+---
+Install the gem:
+
+    gem install sinatra-synchrony
+
+Register with Sinatra __at the top, before any other middleware or plugins are loaded__:
+
+    require 'sinatra/base'
+    require 'sinatra/synchrony'
+    class App < Sinatra::Base
+      register Sinatra::Synchrony
+    end
+
+If you are developing with a classic style app, just require the gem and it will automatically load:
+
+    require 'sinatra'
+    require 'sinatra/synchrony'
+    
+    get '/' do
+      'Sinatra::Synchrony is loaded automatically in classic mode, nothing needed'
+    end
+
+Net::HTTP / TCPSocket
+---
+If you're using anything based on TCPSocket (such as Net::HTTP, which is used by many things), you can replace the native Ruby TCPSocket with one that supports EventMachine and allows for concurrency:
+
+    Sinatra::Synchrony.overload_tcpsocket!
+
+This will allow you to use things like [RestClient](https://github.com/archiloque/rest-client) without any changes:
+
+    RestClient.get 'http://google.com'
+
+This is not perfect though - the TCPSocket overload doesn't currently support SSL and will throw an exception. This is more for when you have ruby libraries that use Net::HTTP and you want to try something. If you intend to do HTTP requests, I strongly recommend using [Faraday](https://github.com/technoweenie/faraday) instead, which has support for [EM-HTTP-Request](https://github.com/igrigorik/em-http-request).
+
+Please encourage Ruby library developers to use (or at least support) Faraday instead of Net::HTTP. Aside from the inability to be concurrent natively, it's a pretty weird and crappy interface, which makes it harder to replace it with something better.
+
+Tests
+---
+Add this to the top of your test file:
+
+    Sinatra::Synchrony.patch_tests!
+
+Then just write your tests as usual, and all tests will be run within EventMachine. You must be in the __test__ environment so that Sinatra will not load Rack::FiberPool.
+
+Benchmarks
+---
+Despite enabling synchronous programming without callbacks, there is no performance hit to your application! All the performance benefits you expect from Thin/Rainbows and EventMachine are still there:
+
+    class App < Sinatra::Base
+      register Sinatra::Synchrony
+      get '/' do
+        'Hello World!'
+      end
+    end
+
+Benchmarked with rackup -s thin:
+
+    $ ab -c 50 -n 2000 http://127.0.0.1:9292/
+    ...
+    Requests per second:    3102.30 [#/sec] (mean)
+    Time per request:       16.117 [ms] (mean)
+    Time per request:       0.322 [ms] (mean, across all concurrent requests)
+
+    Connection Times (ms)
+                  min  mean[+/-sd] median   max
+    Connect:        0    0   0.1      0       1
+    Processing:     5   16   7.7     13      38
+    Waiting:        3   13   7.0     10      35
+    Total:          6   16   7.7     13      38
+
+Let's try a simple blocking IO example to prove it works. 100 hits to google.com:
+
+    require 'sinatra'
+    require 'sinatra/synchrony'
+    require 'rest-client'
+    require 'faraday'
+    Faraday.default_adapter = :em_synchrony
+
+    get '/' do
+      Faraday.get 'http://google.com'
+    end
+
+
+    $ ab -c 100 -n 100 http://127.0.0.1:9292/
+    ...
+    Time taken for tests:   0.256 seconds
+
+For a perspective, this operation takes __33 seconds__ without this extension.
+
+Geoloqi
+---
+This gem was designed to help us develop faster games and internal applications for [Geoloqi](http://geoloqi.org): a real-time geofencing and location update platform. We wanted to share with you how we deal with concurrency issues, and also make it easy to utilize this for our other projects. One of these projects is our recently released [Geoloqi ruby adapter](http://github.com/kyledrake/geoloqi-ruby), which can utilize [Faraday](http://github.com/technoweenie/faraday) and sinatra-synchrony to provide massive concurrency with almost no changes required to your code.
+
+TODO / Thoughts
+---
+* We are using this in production without any problems, and it's very stable for us. But you should test before deploying anything with it.
+* There is work underway to make this a Rack middleware, and integrate that middleware with this plugin. That way, many other frameworks can take advantage of this. There is also work exploratory work to provide support for non-EventMachine Reactor pattern implementations with this approach, but it's beyond the scope of this extension.
+
+Author
+---
+* [Kyle Drake](http://kyledrake.net)
+
+Thanks
+---
+* [Ilya Grigorik](http://www.igvita.com) and [PostRank](http://www.postrank.com) for their amazing work on em-synchrony, em-http-request, and countless articles explaining this.
+* [Mike Perham](http://www.mikeperham.com) and [Carbon Five](http://carbonfive.com). For rack-fiber_pool, em-resolv-replace, and many blog posts and presentations on this.
+* [Konstantin Haase](http://rkh.im/) for session overload suggestion.
+* [Steeve Morin](http://github.com/steeve)
+* [Ryan Caught](https://github.com/rcaught)
+* The many Sinatra developers that liberated me from framework hell, and EventMachine developers that liberated me from blocking IO hell.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require "rake/testtask"
+
+desc "Run all tests"
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/sinatra/synchrony.rb

@@ -0,0 +1,42 @@
+require 'sinatra/base'
+require 'rack/fiber_pool'
+require 'eventmachine'
+require 'em-http-request'
+require 'em-synchrony'
+
+module Sinatra
+  module Synchrony
+    def self.registered(app)
+      app.disable :threaded
+    end
+
+    def setup_sessions(builder)
+      builder.use Rack::FiberPool, {:rescue_exception => handle_exception } unless test?
+      super
+    end
+
+    def handle_exception
+      Proc.new do |env, e|
+        if settings.show_exceptions?
+          request = Sinatra::Request.new(env)
+          printer = Sinatra::ShowExceptions.new(proc{ raise e })
+          s, h, b = printer.call(env)
+          [s, h, b]
+        else
+          [500, {}, ""]
+        end
+      end
+    end
+
+    class << self
+      def patch_tests!
+        require 'sinatra/synchrony/mock_session'
+      end
+
+      def overload_tcpsocket!
+        require 'sinatra/synchrony/tcpsocket'
+      end
+    end
+  end
+  register Synchrony
+end

data/lib/sinatra/synchrony/mock_session.rb

@@ -0,0 +1,13 @@
+require 'rack/test'
+
+module Rack
+  class MockSession
+    alias_method :request_original, :request
+    def request(uri, env)
+      EM.synchrony do
+        request_original uri, env
+        EM.stop
+      end
+    end
+  end
+end

data/lib/sinatra/synchrony/tcpsocket.rb

@@ -0,0 +1,6 @@
+require 'net/http'
+
+original_verbosity = $VERBOSE
+$VERBOSE = nil
+TCPSocket = EventMachine::Synchrony::TCPSocket
+$VERBOSE = original_verbosity

data/spec/synchrony_spec.rb

@@ -0,0 +1,44 @@
+ENV['RACK_ENV'] = 'test'
+require File.join(File.join(File.expand_path(File.dirname(__FILE__))), '..', 'lib', 'sinatra', 'synchrony')
+require 'rack/test'
+require 'minitest/autorun'
+require 'wrong/adapters/minitest'
+Sinatra::Synchrony.patch_tests!
+Wrong.config.alias_assert :expect
+
+def mock_app(base=Sinatra::Base, &block)
+  @app = Sinatra.new(base, &block)
+  @app.set :environment, :test
+  @app.disable :show_exceptions
+  @app.register Sinatra::Synchrony
+end
+def app; @app end
+
+describe 'A mock app' do
+  include Rack::Test::Methods
+  it 'successfully completes a sleep call' do
+    mock_app {
+      get '/' do
+        EM::Synchrony.sleep(0.0001)
+        'ok'
+      end
+    }
+    get '/'
+    expect { last_response.ok? }
+    expect { last_response.body == 'ok' }
+  end
+
+  it 'works with cookie' do
+    mock_app {
+      set :session_secret, 'secret'
+      enable :sessions
+      get '/' do
+        session[:key] = 'val'
+        'ok'
+      end
+    }
+    get '/'
+    expect { last_response.ok? }
+    expect { last_response.headers['Set-Cookie'] }
+  end
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: rubycut-sinatra-synchrony
+version: !ruby/object:Gem::Version
+  version: 0.4.2
+  prerelease: 
+platform: ruby
+authors:
+- Kyle Drake
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rack-fiber_pool
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: wrong
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Bootstraps in code required to take advantage of EventMachine/EM-Synchrony's
+  concurrency enhancements for slow IO. Patches TCPSocket, which makes anything based
+  on it EM-aware (including RestClient). Includes patch for tests. Requires Fibers
+  (Ruby 1.9, JRuby and Rubinius in 1.9 mode)
+email:
+- kyledrake@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sinatra/synchrony.rb
+- lib/sinatra/synchrony/tcpsocket.rb
+- lib/sinatra/synchrony/mock_session.rb
+- spec/synchrony_spec.rb
+- LICENSE.md
+- Rakefile
+- README.md
+- Gemfile
+homepage: https://github.com/kyledrake/sinatra-synchrony
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.4
+requirements: []
+rubyforge_project: rubycut-sinatra-synchrony
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Bootstraps Sinatra with EM-Synchrony code, make TCPSocket EM-aware, provides
+  support for tests
+test_files: []
+has_rdoc: