thin 1.8.2 → 2.0.0.pre

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*.log
+*.pid
+.bundle
+Gemfile.lock
+pkg/*
+tmp
+.yardoc
+test.conf.rb

data/CHANGELOG

@@ -1,90 +1,3 @@
-== 1.8.2 Ruby Razor
- * Ruby 3.2 support.
-
-== 1.8.1 Infinite Smoothie
- * Fix possible HTTP Response Splitting
-
-== 1.8.0 Possessed Pickle
- * Many things
-
-== 1.7.2 Bachmanity
- * Add config support for ssl_version and ssl_cipher_list [frameworked]
-
-== 1.7.1 Muffin Mode
- * Ruby 2.4 support (Fixnum deprecation) [nimish-mehta]
- * Allow ERB templates in config files [markets]
-
-== 1.7.0 Dunder Mifflin
- * Rack 2 support
- * Ensure Response body.close is called in the same thread
-   Fixes issues with ActiveRecord connection management [#307]
- * Fix TCP/IP Backend reports incorrect port when asked to bind to 0 [meschbach]
- * Work with ruby 2.3's --enable-frozen-string-literal [jeremyevans]
-
-== 1.6.4 Gob Bluth
- * Increase REQUEST_PATH to 2048 symbols [X2rdas]
- * Fix warning in logger [tenderlove]
- * Add :timeout option for Rack::Server.new [sugitak]
- * When restarting, exit on a next tick so we can send response back to a client [rsamoilov]
- * Check for empty PID files [z1dane]
- * Update Event Machine version to 1.0.4, Ruby 2.2.0 fix [freemanoid]
-
-== 1.6.3 Protein Powder
- * Add HTTP 422 status code [rajcybage]
- * Add warning about EM reactor still running when stopping.
- * Remove version number from "Server" HTTP header. [benbasson]
- * Adding `--ssl-disable-verify` to allow disabling of client cert requests when SSL enabled [brucek]
- * Ensure Tempfiles created by a large request are closed and deleted. [Tonkpils]
-
-== 1.6.2 Doc Brown
- * No longer replace response's body on HEAD request. Ensuring body.close will be called.
- * Remove `---ssl-verify` option as EventMachine doesn't verify the certificate.
- * Fix env['rack.peer_cert'] to return SSL certifcate.
-
-== 1.6.1 Death Proof
- * Regression: Default logger to STDOUT when using outside of CLI.
- * Regression: Downgrade Rack required version back to 1.0 to work w/ prior Rails versions.
-
-== 1.6.0 Greek Yogurt
- * Accept absolute URL in request line, eg.: 'GET http://site.com/he/lo HTTP/1.1'.
- * HEAD request no longer return a body in the response.
- * No longer stop EventMachine's reactor loop unless it was started by Thin.
- * Make request env keys upcasing locale-agnostic.
- * Use Ruby's `Logger` for logging. [Akshay Moghe].
-   The logger can now be set using `Thin::Logging.logger=`.
-   Tracing of request is handled by a second logger, `Thin::Logging.trace_logger=`.
- * Add --threadpool-size option to configure EM's thread pool size (default: 20).
- * Pipelining is no longer supported.
-
-== 1.5.1 Straight Razor
- * Fix issue when running as another user/group without a PID file.
- * Allow overriding Connection & Server response headers.
- * Update vlad example [Mathieu Lemoine]
- * Keep connections in a Hash to speedup deletion [slivu]
- * Force kill using already known pid. Prevents "thin stop" from leaving a process that removed its
-   pid file, but is still running (e.g. hung on some at_exit callback) [Michal Kwiatkowski]
-
-== 1.5.0 Knife
- * Fix compilation under Ubuntu 12.04 with -Werror=format-security option.
- * Raise an error when no PID file.
- * Prevent duplicate response headers.
- * Make proper response on exception [MasterLambaster].
- * Automatically close idling pipeline connections on server stop [MasterLambaster].
-
-== 1.4.1 Chromeo Fix
- * Fix error when sending USR1 signal and no log file is supplied.
-
-== 1.4.0 Chromeo
- * kill -USR1 $PID for log rotation [catwell].
- * Fix HUP signal being reseted after deamonization [atotic].
- * Fix error with nil addresses in Connection#socket_address.
-
-== 1.3.2 Low-bar Squat
- * Remove mack and halcyon Rack adapters from automatic detection.
-
-== 1.3.1 Triple Espresso
- * Fix service not working pre 1.9.
-
 == 1.3.0 Double Espresso
  * BREAKING CHANGE: Thin no longer ships with fat Windows binaries.
    From now on, to install on Windows, install https://github.com/oneclick/rubyinstaller/wiki/Development-Kit.
@@ -92,10 +5,10 @@
    It is now the responsibility of the app (or a middleware) to set the Content-Length.
  * Log errors to STDERR [textgoeshere]
  * Shut down gracefully when receiving SIGTERM [ddollar]
-
+     
      Processes are allowed a chance to shut down gracefully when receiving
      SIGTERM (http://en.wikipedia.org/wiki/SIGTERM).
-
+     
      On Heroku, when shutting down a process, we send a SIGTERM followed 10
      seconds later with a SIGKILL, similar to the behavior of the init daemon
      on most Unix systems. This patch will allow Heroku apps to shut down
@@ -120,7 +33,7 @@
      the existing connection to another protocol, and specifically is NOT
      used to upgrade a separate connection. Therefore, the connection must
      remain open after this response in order to facilitate that.
-
+   
  * Accept IE7 badly encoded URL (eg.: %uEEEE)
  * Fix gemspec to work w/ Bundler [smparkes]
  * Add SSL support [tmm1]
@@ -136,10 +49,10 @@
       --ssl-key-file PATH      Path to private key
       --ssl-cert-file PATH     Path to certificate
       --ssl-verify             Enables SSL certificate verification
-
+    
   * Expose peer SSL certificate in env (rack.peer_cert) [fd]
   * Adjusting unix socket permissions to be more open [mbj]
-
+  
 == 1.2.7 No Hup
  * Support multiple Ruby version (fat binaries under windows)
  * Do not trap unsupported HUP signal on Windows
@@ -163,7 +76,7 @@
 == 1.2.2 I Find Your Lack of Sauce Disturbing release
  * Fix force kill under 1.9 [Alexey Chebotar]
  * Fix regression when --only option is used w/ --socket.
- * Add process name 'tag' functionality. Easier to distinguish thin daemons
+ * Add process name 'tag' functionality. Easier to distinguish thin daemons 
    from eachother in process listing [ctcherry]
 
 == 1.2.1 Asynctilicious Ultra Supreme release
@@ -173,11 +86,11 @@
  * Allow String for response body
  * Require openssl before eventmachine to prevent crash in 1.9
 
-== 1.2.0 Asynctilicious Supreme release
+== 1.2.0 Asynctilicious Supreme release 
  * Add support for Windows mingw Ruby distro [Juan C. Rodriguez]
  * Add async response support, see example/async_*.ru [raggi]
 
-== 1.1.1 Super Disco Power Plus release
+== 1.1.1 Super Disco Power Plus release 
  * Fix bug when running with only options [hasimo]
 
 == 1.1.0 Super Disco Power release
@@ -274,20 +187,20 @@
  * Add tasks for Vlad the Deployer in example/vlad.rake [cnantais]
  * Add Ramaze Rackup config file in example dir [tmm1]
    Use like this from you Ramaze app dir:
-
+   
      thin start -r /path/to/thin/example/ramaze.ru
-
+   
  * Add the --rackup option to load a Rack config file instead of the Rails adapter.
    So you can use any framework with the thin script and start cluster and stuff like that.
    A Rack config file is one that is usable through the rackup command and looks like this:
-
+     
      use Rack::CommonLogger
      run MyCrazyRackAdapter.new(:uterly, 'cool')
-
+     
    Then use it with thin like this:
-
+     
      thin start --rackup config.ru
-
+     
  * thin config --chrdir ... -C thin/yml do not change current directory anymore, fixes #33.
  * Add a better sample god config file in example/thin.god that loads all info from config
    files in /etc/thin. Drop-in replacement for the thin runlevel service [Gump].
@@ -295,9 +208,9 @@
    configuration.
  * Add a script to run thin as a runlevel service that can start at startup, closes #31 [Gump]
    Setup the service like this:
-
+   
      sudo thin install /etc/thin
-
+   
    This will install the boot script under /etc/init.d/thin. Then copy your config files to
    /etc/thin. Works only under Linux.
  * Set process name to 'thin server (0.0.0.0:3000)' when running as a daemon, closes #32.
@@ -323,9 +236,9 @@
  * Add example config files for http://www.tildeslash.com/monit usage.
    Include the example file using "include /path/to/thin/monit/file" in your monitrc file.
    The group settings let you do this to manage your clusters:
-
+   
      sudo monit -g blog restart all
-
+    
    There are examples of thin listening on sockets and thin listening on unix sockets.
 
 == 0.6.1 Cheesecake release
@@ -336,20 +249,20 @@
  * Add support for connection through UNIX domain socket.
    Use the --socket (-S) option w/ the thin script to configure the socket filename.
    Nginx support binding to a UNIX socket like this:
-
+   
      upstream  backend {
        server   unix:/tmp/thin.0.sock;
        server   unix:/tmp/thin.1.sock;
        server   unix:/tmp/thin.2.sock;
      }
-
+  
    Start your servers like this:
-
+   
      thin start -s3 -S/tmp/thin.sock
-
+   
  * Remove Server#listen! method. Use Server#start instead.
  * Server can now yield a Rack::Builder to allow building an app in one call:
-
+ 
      Server.start '0.0.0.0', 3000 do
        use Rack::CommonLogger
        use Rack::ShowExceptions
@@ -358,13 +271,13 @@
          run Rack::Lobster.new
        end
      end
-
+     
  * Add a very basic stats page through Stats adapter, load w/ --stats and browse to /stats.
  * Add --trace (-V) option to trace request/response and get backtrace w/out all Ruby debug stuff.
  * Add --config (-C) option to load options from a config file in thin script [Matt Todd].
  * Alter response headers to output directly to a string.
  * Improve specs stability.
- * Move request body to a Tempfile if too big (> 112 KB)
+ * Move request body to a Tempfile if too big (> 112 MB)
  * Remove useless check for max header size in Request (already done in the parser)
 
 == 0.5.4 Flying Mustard release
@@ -376,7 +289,7 @@
    Thanks to Kent Sibilev and Ezra for their help on that one.
  * Add 'Server' response header
  * Fix --user and --group option not changing daemon process privileges
-
+ 
 == 0.5.3 Purple Yogurt release
  * win32 pre-compiled gem now available
  * change rake task configuration to allow win32 gem build
@@ -396,7 +309,7 @@
      --log-file => --log
      --pid-file => --pid
      --env      => --environment
-
+ 
 == 0.5.1 LOLCAT release
  * Add URL rewriting to Rails adapter so that page caching works and / fetches index.html if present.
  * Fix bug in multiline response header parsing.
@@ -411,9 +324,9 @@
 
 == 0.5.0
  * Full rewrite to use EventMachine, Rack and Mongrel parser
-
+ 
 == 0.4.1
  * Fix Rails environment option not being used in thin script.
-
+ 
 == 0.4.0
  * First alphaish release as a gem.

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in thin.gemspec
+gemspec
+
+group :test do
+  gem "mocha", "~> 0.10.0"
+end

data/README.md

@@ -1,102 +1,68 @@
-# Thin
-
-A small and fast Ruby web server
-
-## Installation
-
-```
-gem install thin
-```
-
-Or add `thin` to your `Gemfile`:
-
-```ruby
-gem 'thin'
-```
-
-## Usage
+---
 
-A +thin+ script offers an easy way to start your Rack application:
+# This is alpha software. Things might break, people will cry and it will be your fault.
+### When reporting issues, make sure to mention you're using Thin v2.
 
-```
-thin start
-```
+---
 
-Browse the `example` directory for sample applications.
-
-## Usage with Rails Action Cable
+# Thin
+Tiny, fast & funny Ruby server
 
-To use Thin with Action Cable, add the following to your `Gemfile`:
+Thin is a high performance and customizable Ruby server. It's structured much like Nginx. A
+master process listen to incoming requests and dispatch to its worker processes, each one
+running an EventMachine event loop.
 
-```ruby
-gem 'faye-websocket'
-gem 'thin' # If not already done
-```
+Which makes it, with all humility, the most secure, stable, fast and extensible Ruby web server
+bundled in an easy to use gem for your own pleasure.
 
-Create a `config/initializers/thin_action_cable.rb`:
+**Site:**  http://code.macournoyer.com/thin/  
+**Group:** http://groups.google.com/group/thin-ruby/topics  
+**Bugs:**  http://github.com/macournoyer/thin/issues  
+**Code:**  http://github.com/macournoyer/thin  
+**IRC:**   #thin on freenode  
 
-```ruby
-Rails.application.config.action_cable.use_faye = true
-Faye::WebSocket.load_adapter 'thin'
-```
+## Features
 
-### CLI
+ * Prefork model with an EventMachine loop running in each worker.
+ * Optional single process mode for non-UNIX systems and simpler deployments.
+ * Optional threaded mode using a pool of threads.
+ * Easy asynchronous streaming response support with chunked encoding.
+ * Fast file serving with automatic streaming for large files.
+ * Keep-alive support.
+ * SSL support (upcoming).
 
-Use a rackup (config.ru) file and bind to localhost port 8080:
+## Installation
+For this pre-release of version 2.0:
 
-```
-thin -R config.ru -a 127.0.0.1 -p 8080 start
-```
+    $ gem install thin --pre
 
-Store the server process ID, log to a file and daemonize:
+Or from source:
 
-```
-thin -p 9292 -P tmp/pids/thin.pid -l logs/thin.log -d start
-```
+    $ git clone git://github.com/macournoyer/thin.git
+    $ git checkout v2
+    $ cd thin
+    $ bundle install
+    $ rake install
 
-Thin is quite flexible in that many options can be specified at the command line (see `thin -h` for more).
+## Usage
+The `thin` script offers an easy way to start your Rack based application and acts just like
+the `rackup` script.:
 
-### Configuration files
+    $ cd to/your/rack/app
+    $ thin
 
-You can create a configuration file using `thin config -C config/thin.yml`.
+To use with Rails, add thin to your Gemfile and use Rails server command:
 
-You can then use it with all commands, such as: `thin start -C config/thin.yml`.
+    $ echo "gem 'thin'" >> Gemfile
+    $ bundle install
+    $ rails server thin
 
-Here is an example config file:
+See examples/thin.conf.rb for a sample configuration file.
 
-```yaml
---- 
-user: www-data
-group: www-data
-pid: tmp/pids/thin.pid
-timeout: 30
-wait: 30
-log: log/thin.log
-max_conns: 1024
-require: []
-environment: production
-max_persistent_conns: 512
-servers: 1
-threaded: true
-no-epoll: true
-daemonize: true
-socket: tmp/sockets/thin.sock
-chdir: /path/to/your/apps/root
-tag: a-name-to-show-up-in-ps aux
-```
+Run `thin -h` to list available options.
 
 ## License
-
 Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
 
 ## Credits
-
-The parser was originally from Mongrel http://mongrel.rubyforge.org by Zed Shaw.
-Mongrel is copyright 2007 Zed A. Shaw and contributors. It is licensed under
-the Ruby license and the GPL2.
-
 Thin is copyright Marc-Andre Cournoyer <macournoyer@gmail.com>
-
-Get help at http://groups.google.com/group/thin-ruby/
-Report bugs at https://github.com/macournoyer/thin/issues
-and major security issues directly to me at macournoyer@gmail.com.

data/Rakefile

@@ -1,25 +1,35 @@
-require 'rake'
-require 'rake/clean'
-load 'thin.gemspec'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-# Load tasks in tasks/
-Dir['tasks/**/*.rake'].each { |rake| load rake }
+require 'rake/testtask'
+require "thin/version"
 
-task :default => :spec
-
-desc "Build gem packages"
-task :build do
-  sh "gem build thin.gemspec"
+namespace :test do
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << 'lib'
+    t.libs << 'test'
+    t.pattern = 'test/unit/**/*_test.rb'
+  end
+  
+  Rake::TestTask.new(:integration) do |t|
+    t.libs << 'lib'
+    t.libs << 'test'
+    t.pattern = 'test/integration/**/*_test.rb'
+  end
+  
 end
+desc "Run all tests"
+task :test => ["test:unit", "test:integration"]
 
-desc "Push gem packages"
-task :push => :build do
-  sh "gem push thin-*.gem"
-end
+task :default => :test
 
-task :install => :build do
-  sh "gem install thin-*.gem"
+task :man do
+  ENV['RONN_MANUAL']  = "Thin Manual"
+  ENV['RONN_ORGANIZATION'] = "Thin #{Thin::VERSION::STRING}"
+  sh "ronn -w -s toc -5 man/*.ronn"
+  mv FileList["man/*.html"], "site/public/man"
 end
 
-desc "Release version #{Thin::VERSION::STRING}"
-task :release => [:tag, :push]
+task :rm_space do
+  sh %{find . -name "*.rb" -print0 | xargs -0 sed -i '' -E "s/[[:space:]]*$//"}
+end

data/bin/thin

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-# Thin command line interface script.
-# Run <tt>thin -h</tt> to get more usage.
 
-require 'thin'
-Thin::Runner.new(ARGV).run!
+require "thin"
+require "thin/runner"
+
+Thin::Runner.run(ARGV)

data/examples/async.ru

@@ -0,0 +1,21 @@
+require "thin/async"
+
+class Async
+  def call(env)
+    response = Thin::AsyncResponse.new(env)
+    
+    # Webkit requires some padding before displaying something.
+    response << " " * 1024
+    
+    response << "this is ... "
+    # Will be sent to the browse 1 sec after.
+    EM.add_timer(1) do
+      response << "async stuff!"
+      response.done # close the connection
+    end
+    
+    response.finish
+  end
+end
+
+run Async.new

data/examples/thin.conf.rb

@@ -0,0 +1,39 @@
+# Event backend options
+worker_connections 1024
+# Disabling epoll or kqueue will fallback to select.
+# use_epoll false
+# use_kqueue false
+
+# Threading
+# For slow apps, you can enable the use of threads.
+# If you're using this in Rails, make sure to call config.threadsafe!
+threaded true # Call the app in a thread.
+thread_pool_size 20
+
+# Worker options
+# worker_processes 0 # runs in a single process w/ limited features.
+worker_processes 4
+timeout 30 # seconds
+
+# Preload the app (the .ru file) before forking to workers.
+# Enable with copy-on-write garbage collection for better memory usage.
+preload_app true
+
+# Logging
+log_path "./thin.log"
+pid_path "./thin.pid"
+
+# Listeners
+listen 3000, :backlog => 1024, :tcp_no_delay => true
+listen "0.0.0.0:8080"
+listen "[::]:8081" # IPv6
+listen "/tmp/thin.sock" # UNIX domain socket
+
+# Callbacks
+before_fork do |server|
+  puts "Preparing to fork a new worker ..."
+end
+
+after_fork do |server|
+  puts "Worker forked!"
+end

data/lib/thin/async.rb

@@ -0,0 +1,108 @@
+module Thin
+  unless defined?(DeferrableBody)
+    # Based on version from James Tucker <raggi@rubyforge.org>
+    class DeferrableBody
+      include EM::Deferrable
+
+      def initialize
+        @queue = []
+      end
+
+      def call(body)
+        @queue << body
+        schedule_dequeue
+      end
+
+      def each(&blk)
+        @body_callback = blk
+        schedule_dequeue
+      end
+  
+      private
+        def schedule_dequeue
+          return unless @body_callback
+          EM.next_tick do
+            next unless body = @queue.shift
+            body.each do |chunk|
+              @body_callback.call(chunk)
+            end
+            schedule_dequeue unless @queue.empty?
+          end
+        end
+    end
+  end
+  
+  # Response whos body is sent asynchronously.
+  # 
+  # A nice wrapper around Thin's obscure async callback used to send response body asynchronously.
+  # Which means you can send the response in chunks while allowing Thin to process other requests.
+  # 
+  # Crazy delicious with em-http-request for file upload, image processing, proxying, etc.
+  # 
+  # == _WARNING_
+  # You should not use long blocking operations (Net::HTTP or slow shell calls) with this as it
+  # will prevent the EventMachine event loop from running and block all other requests.
+  #
+  # Also disable the Rack::Lint middleware to use Thin's async feature since it requires sending
+  # back an invalid status code to the server.
+  # 
+  # == Usage
+  # Inside your Rack app #call(env):
+  # 
+  #     response = Thin::AsyncResponse.new(env)
+  #     response.status = 201
+  #     response.headers["X-Muffin-Mode"] = "ACTIVATED!"
+  # 
+  #     response << "this is ... "
+  # 
+  #     EM.add_timer(1) do
+  #       # This will be sent to the client 1 sec later without blocking other requests.
+  #       response << "async!"
+  #       response.done
+  #     end
+  # 
+  #     response.finish
+  #
+  class AsyncResponse
+    include Rack::Response::Helpers
+    
+    Marker = [-1, {}, []].freeze
+    
+    attr_reader :headers, :callback
+    attr_accessor :status
+    
+    def initialize(env, status=200, headers={})
+      @callback = env['async.callback']
+      @body = DeferrableBody.new
+      @status = status
+      @headers = headers
+      @headers_sent = false
+      
+      yield self if block_given?
+    end
+    
+    def send_headers(response=nil)
+      return if @headers_sent
+      @callback.call response || [@status, @headers, @body]
+      @headers_sent = true
+    end
+    
+    def write(body)
+      send_headers
+      @body.call(body.respond_to?(:each) ? body : [body])
+    end
+    alias :<< :write
+    
+    # Tell Thin the response is complete and the connection can be closed.
+    def done(response=nil)
+      send_headers(response)
+      EM.next_tick { @body.succeed }
+    end
+    
+    # Tell Thin the response is gonna be sent asynchronously.
+    # The status code of -1 is the magic trick here.
+    def finish
+      Marker
+    end
+  end
+end