thin 1.8.0 → 2.0.0.pre

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.rb

@@ -1,45 +1,3 @@
-require 'fileutils'
-require 'timeout'
-require 'stringio'
-require 'time'
-require 'forwardable'
-require 'openssl'
-require 'eventmachine'
-require 'rack'
-
-module Thin
-  autoload :Command,            "thin/command"
-  autoload :Connection,         "thin/connection"
-  autoload :Daemonizable,       "thin/daemonizing"
-  autoload :Logging,            "thin/logging"
-  autoload :Headers,            "thin/headers"
-  autoload :Request,            "thin/request"
-  autoload :Response,           "thin/response"
-  autoload :Runner,             "thin/runner"
-  autoload :Server,             "thin/server"
-  autoload :Stats,              "thin/stats"
-  
-  module Backends
-    autoload :Base,             "thin/backends/base"
-    autoload :SwiftiplyClient,  "thin/backends/swiftiply_client"
-    autoload :TcpServer,        "thin/backends/tcp_server"
-    autoload :UnixServer,       "thin/backends/unix_server"
-  end
-  
-  module Controllers
-    autoload :Cluster,          "thin/controllers/cluster"
-    autoload :Controller,       "thin/controllers/controller"
-    autoload :Service,          "thin/controllers/service"
-  end
-end
-
 require "thin/version"
-require "thin/statuses"
-require "rack/adapter/loader"
-require "thin_parser"
-
-module Rack
-  module Adapter
-    autoload :Rails, "rack/adapter/rails"
-  end
-end
+require "thin/system"
+require "thin/server"

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

data/lib/thin/backends/prefork.rb

@@ -0,0 +1,44 @@
+require "preforker"
+
+module Thin
+  module Backends
+    class Prefork
+      def initialize(server)
+        @server = server
+      end
+
+      def start(daemonize)
+        @server.before_fork.call(@server) if @server.before_fork
+
+        @prefork = Preforker.new(
+                     :app_name => @server.to_s,
+                     :workers => @server.worker_processes,
+                     :timeout => @server.timeout,
+                     :pid_path => @server.pid_path,
+                     :stderr_path => @server.log_path,
+                     :stdout_path => @server.log_path,
+                     :logger => Logger.new(@server.log_path || $stdout)
+                   ) do |master|
+
+          EM.run do
+            EM.add_periodic_timer(4) do
+              EM.stop_event_loop unless master.wants_me_alive?
+            end
+
+            @server.after_fork.call(@server, master) if @server.after_fork
+
+            yield
+          end
+        end
+
+        if daemonize
+          @prefork.start
+        else
+          @prefork.run
+        end
+
+        at_exit { @server.stop }
+      end
+    end
+  end
+end

data/lib/thin/backends/single_process.rb

@@ -0,0 +1,28 @@
+module Thin
+  module Backends
+    class SingleProcess
+      def initialize(server)
+        @server = server
+      end
+
+      def start(daemonize)
+        raise NotImplementedError, "Daemonization not supported in single process mode" if daemonize
+
+        @pid_manager = Preforker::PidManager.new(@server.pid_path)
+
+        $0 = @server.to_s
+
+        # Install signals
+        %w( INT TERM ).each { |signal| trap(signal, "EXIT") }
+        at_exit do
+          @server.stop
+          @pid_manager.unlink
+        end
+
+        EM.run do
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/thin/chunked_body.rb

@@ -0,0 +1,28 @@
+module Thin
+  # Same as Rack::Chunked::Body, but doesn't send the tail automaticaly.
+  class ChunkedBody
+    TERM = "\r\n"
+    TAIL = "0#{TERM}#{TERM}"
+
+    include Rack::Utils
+
+    def initialize(body)
+      @body = body
+    end
+
+    def each
+      term = TERM
+      @body.each do |chunk|
+        size = bytesize(chunk)
+        next if size == 0
+
+        chunk = chunk.dup.force_encoding(Encoding::BINARY) if chunk.respond_to?(:force_encoding)
+        yield [size.to_s(16), term, chunk, term].join
+      end
+    end
+
+    def close
+      @body.close if @body.respond_to?(:close)
+    end
+  end
+end

data/lib/thin/configurator.rb

@@ -0,0 +1,118 @@
+module Thin
+  class Configurator
+    attr_reader :options
+
+    def initialize(defaults={}, &block)
+      @options = defaults.dup
+      @options[:listeners] ||= []
+      
+      instance_eval(&block) if block
+    end
+
+    # {include:Thin::Server#worker_processes}
+    # @see Thin::Server#worker_processes
+    def worker_processes(number)
+      set :worker_processes, number, Integer
+    end
+
+    # {include:Thin::Server#worker_connections}
+    # @see Thin::Server#worker_connections
+    def worker_connections(number)
+      set :worker_connections, number, Integer
+    end
+
+    # {include:Thin::Server#listen}
+    # @see Thin::Server#listen
+    def listen(address, options={})
+      @options[:listeners] << Listener.new(address, options)
+    end
+
+    # {include:Thin::Server#preload_app}
+    # @see Thin::Server#preload_app
+    def preload_app(value)
+      set :preload_app, value, TrueClass, FalseClass
+    end
+
+    # {include:Thin::Server#timeout}
+    # @see Thin::Server#timeout
+    def timeout(seconds)
+      set :timeout, seconds, Integer
+    end
+
+    # {include:Thin::Server#timeout}
+    # @see Thin::Server#timeout
+    def keep_alive_requests(number)
+      set :max_keep_alive_requests, number, Integer
+    end
+
+    # {include:Thin::Server#log_path}
+    # @see Thin::Server#log_path
+    def log_path(path)
+      set :log_path, path, String
+    end
+
+    # {include:Thin::Server#pid_path}
+    # @see Thin::Server#pid_path
+    def pid_path(path)
+      set :pid_path, path, String
+    end
+
+    # {include:Thin::Server#use_epoll}
+    # @see Thin::Server#use_epoll
+    def use_epoll(value)
+      set :use_epoll, value, TrueClass, FalseClass
+    end
+
+    # {include:Thin::Server#use_kqueue}
+    # @see Thin::Server#use_kqueue
+    def use_kqueue(value)
+      set :use_kqueue, value, TrueClass, FalseClass
+    end
+
+    # {include:Thin::Server#threaded}
+    # @see Thin::Server#threaded
+    def threaded(value)
+      set :threaded, value, TrueClass, FalseClass
+    end
+
+    # {include:Thin::Server#thread_pool_size}
+    # @see Thin::Server#thread_pool_size
+    def thread_pool_size(value)
+      set :thread_pool_size, value, Integer
+    end
+
+    # {include:Thin::Server#before_fork}
+    # @see Thin::Server#before_fork
+    def before_fork(&block)
+      @options[:before_fork] = block
+    end
+
+    # {include:Thin::Server#after_fork}
+    # @see Thin::Server#after_fork
+    def after_fork(&block)
+      @options[:after_fork] = block
+    end
+
+    # Apply this configuration to the +server+ instance.
+    # @param [Thin::Server] server
+    def apply(server)
+      @options.each_pair { |name, value| server.send "#{name}=", value }
+      server
+    end
+
+    # Read and eval a configuration file and returns the resulting Configurator instance.
+    def self.load(file)
+      config = new
+      config.instance_eval(File.read(file), file)
+      config
+    end
+
+    private
+      def set(name, value, *classes)
+        if classes.any? && classes.none? { |c| value.is_a?(c) }
+          raise ArgumentError, "#{name}: #{value.inspect} is not of type " + classes.join(' or ')
+        end
+        @options[name] = value
+      end
+  end
+end