thin 0.5.3-x86-mswin32-60

data/lib/rack/adapter/rails.rb

@@ -0,0 +1,155 @@
+# This as been submitted to Rack as a patch, tested and everything.
+# Bug Christian Neukirchen at chneukirchen@gmail.com to apply the patch!
+
+require 'cgi'
+
+# Adapter to run a Rails app with any supported Rack handler.
+# By default it will try to load the Rails application in the
+# current directory in the development environment.
+# Options:
+#  root: Root directory of the Rails app
+#  env: Rails environment to run in (development, production or test)
+# Based on http://fuzed.rubyforge.org/ Rails adapter
+module Rack
+  module Adapter 
+    class Rails
+      def initialize(options={})
+        @root   = options[:root]         || Dir.pwd
+        @env    = options[:environment]  || 'development'
+        @prefix = options[:prefix]
+        
+        load_application
+        
+        @file_server = Rack::File.new(::File.join(RAILS_ROOT, "public"))
+      end
+      
+      def load_application
+        ENV['RAILS_ENV'] = @env
+
+        require "#{@root}/config/environment"
+        require 'dispatcher'
+        
+        ActionController::AbstractRequest.relative_url_root = @prefix if @prefix 
+      end
+      
+      # TODO refactor this in File#can_serve?(path) ??
+      def file_exist?(path)
+        full_path = ::File.join(@file_server.root, Utils.unescape(path))
+        ::File.file?(full_path) && ::File.readable?(full_path)
+      end
+      
+      def serve_file(env)
+        @file_server.call(env)
+      end
+      
+      def serve_rails(env)
+        request         = Request.new(env)
+        response        = Response.new
+        
+        session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS
+        cgi             = CGIWrapper.new(request, response)
+    
+        Dispatcher.dispatch(cgi, session_options, response)
+
+        response.finish
+      end
+      
+      def call(env)
+        path        = env['PATH_INFO'].chomp('/')
+        cached_path = (path.empty? ? 'index' : path) + ActionController::Base.page_cache_extension
+        
+        if file_exist?(path)              # Serve the file if it's there
+          serve_file(env)
+        elsif file_exist?(cached_path)    # Serve the page cache if it's there
+          env['PATH_INFO'] = cached_path
+          serve_file(env)
+        else                              # No static file, let Rails handle it
+          serve_rails(env)
+        end
+      end
+    
+      protected
+        
+        class CGIWrapper < ::CGI
+          def initialize(request, response, *args)
+            @request  = request
+            @response = response
+            @args     = *args
+            @input    = request.body
+
+            super *args
+          end
+        
+          def header(options = "text/html")
+            if options.is_a?(String)
+              @response['Content-Type']     = options unless @response['Content-Type']
+            else
+              @response['Content-Length']   = options.delete('Content-Length').to_s if options['Content-Length']
+            
+              @response['Content-Type']     = options.delete('type') || "text/html"
+              @response['Content-Type']    += "; charset=" + options.delete('charset') if options['charset']
+                        
+              @response['Content-Language'] = options.delete('language') if options['language']
+              @response['Expires']          = options.delete('expires') if options['expires']
+
+              @response.status              = options.delete('Status') if options['Status']
+              
+              # Convert 'cookie' header to 'Set-Cookie' headers.
+              # Because Set-Cookie header can appear more the once in the response body, 
+              # we store it in a line break seperated string that will be translated to
+              # multiple Set-Cookie header by the handler.
+              if cookie = options.delete('cookie')
+                cookies = []
+                
+                case cookie
+                  when Array then cookie.each { |c| cookies << c.to_s }
+                  when Hash  then cookie.each { |_, c| cookies << c.to_s }
+                  else            cookies << cookie.to_s
+                end
+        
+                @output_cookies.each { |c| cookies << c.to_s } if @output_cookies
+                
+                @response['Set-Cookie'] = [@response['Set-Cookie'], cookies].compact.join("\n")
+              end
+              
+              options.each { |k,v| @response[k] = v }
+            end
+            
+            ""
+          end
+                        
+          def params
+            @params ||= @request.params
+          end
+        
+          def cookies
+            @request.cookies
+          end
+        
+          def query_string
+            @request.query_string
+          end
+          
+          # Used to wrap the normal args variable used inside CGI.
+          def args
+            @args
+          end
+    
+          # Used to wrap the normal env_table variable used inside CGI.
+          def env_table
+            @request.env
+          end
+    
+          # Used to wrap the normal stdinput variable used inside CGI.
+          def stdinput
+            @input
+          end
+        
+          def stdoutput
+            STDERR.puts "stdoutput should not be used."
+            @response.body
+          end
+      end
+    end
+  end
+end

data/lib/rack/handler/thin.rb

@@ -0,0 +1,13 @@
+module Rack
+  module Handler
+    class Thin
+      def self.run(app, options={})
+        server = ::Thin::Server.new(options[:Host] || '0.0.0.0',
+                                    options[:Port] || 8080,
+                                    app)
+        yield server if block_given?
+        server.start!
+      end
+    end
+  end
+end

data/lib/thin.rb

@@ -0,0 +1,36 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'fileutils'
+require 'timeout'
+require 'stringio'
+
+require 'rubygems'
+require 'eventmachine'
+
+require 'thin/version'
+require 'thin/statuses'
+
+module Thin
+  NAME    = 'thin'.freeze
+  SERVER  = "#{NAME} #{VERSION::STRING} codename #{VERSION::CODENAME}".freeze  
+  
+  autoload :Cluster,      'thin/cluster'
+  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 :Server,       'thin/server'
+end
+
+require 'rack'
+
+module Rack
+  module Handler
+    autoload :Thin, 'rack/handler/thin'
+  end
+  module Adapter
+    autoload :Rails, 'rack/adapter/rails'
+  end
+end

data/lib/thin/cluster.rb

@@ -0,0 +1,106 @@
+module Thin
+  # Control a set of servers.
+  # * Generate start and stop commands and run them.
+  # * Inject the port number in the pid and log filenames.
+  # Servers are started throught the +thin+ commandline script.
+  class Cluster
+    include Logging
+    
+    # Path to the +thin+ script used to control the servers.
+    # Leave this to default to use the one in the path.
+    attr_accessor :script
+    
+    # Number of servers in the cluster.
+    attr_accessor :size
+    
+    # Command line options passed to the thin script
+    attr_accessor :options
+    
+    # Create a new cluster of servers launched using +options+.
+    def initialize(options)
+      @options = options.merge(:daemonize => true)
+      @size    = @options.delete(:servers)
+      @script  = 'thin'
+    end
+    
+    def first_port; @options[:port]     end
+    def address;    @options[:address]  end    
+    def pid_file;   File.expand_path File.join(@options[:chdir], @options[:pid]) end
+    def log_file;   File.expand_path File.join(@options[:chdir], @options[:log]) end
+    
+    # Start the servers
+    def start
+      with_each_server { |port| start_on_port port }
+    end
+    
+    # Start the server on a single port
+    def start_on_port(port)
+      log "Starting #{address}:#{port} ... "
+      
+      run :start, @options, port
+    end
+  
+    # Stop the servers
+    def stop
+      with_each_server { |port| stop_on_port port }
+    end
+    
+    # Stop the server running on +port+
+    def stop_on_port(port)
+      log "Stopping #{address}:#{port} ... "
+      
+      run :stop, @options, port
+    end
+    
+    # Stop and start the servers.
+    def restart
+      stop
+      sleep 0.1 # Let's breath a bit shall we ?
+      start
+    end
+    
+    def log_file_for(port)
+      include_port_number log_file, port
+    end
+    
+    def pid_file_for(port)
+      include_port_number pid_file, port
+    end
+    
+    def pid_for(port)
+      File.read(pid_file_for(port)).chomp.to_i
+    end
+    
+    private
+      # Send the command to the +thin+ script
+      def run(cmd, options, port)
+        shell_cmd = shellify(cmd, options.merge(:port => port, :pid => pid_file_for(port), :log => log_file_for(port)))
+        trace shell_cmd
+        ouput = `#{shell_cmd}`.chomp
+        log ouput unless ouput.empty?
+      end
+      
+      # Turn into a runnable shell command
+      def shellify(cmd, options)
+        shellified_options = options.inject([]) do |args, (name, value)|
+          args << case value
+          when NilClass
+          when TrueClass then "--#{name}"
+          else                "--#{name.to_s.tr('_', '-')}=#{value.inspect}"
+          end
+        end
+        "#{@script} #{cmd} #{shellified_options.compact.join(' ')}"
+      end
+      
+      def with_each_server
+        @size.times { |n| yield first_port + n }
+      end
+      
+      # Add the port numbers in the filename
+      # so each instance get its own file
+      def include_port_number(path, port)
+        raise ArgumentError, "filename '#{path}' must include an extension" unless path =~ /\./
+        path.gsub(/\.(.+)$/) { ".#{port}.#{$1}" }
+      end
+  end
+end

data/lib/thin/connection.rb

@@ -0,0 +1,46 @@
+require 'socket'
+
+module Thin
+  class Connection < EventMachine::Connection
+    include Logging
+    
+    attr_accessor :app
+    
+    def post_init
+      @request  = Request.new
+      @response = Response.new
+    end
+    
+    def receive_data(data)
+      trace { data }
+			process if @request.parse(data)
+    rescue InvalidRequest => e
+      log "Invalid request"
+      log_error e
+      close_connection
+    end
+    
+    def process
+      env = @request.env
+      
+      # Add client info to the request env
+      env[Request::REMOTE_ADDR] = env[Request::FORWARDED_FOR] || Socket.unpack_sockaddr_in(get_peername)[1]
+
+      # Process the request
+      @response.status, @response.headers, @response.body = @app.call(env)
+      
+      # Send the response
+      trace { @response.to_s }
+      send_data @response.to_s
+      
+      close_connection_after_writing
+      
+    rescue Object => e
+      log "Unexpected error while processing request: #{e.message}"
+      log_error e
+      close_connection rescue nil
+    ensure
+      @response.close rescue nil
+    end
+  end
+end

data/lib/thin/daemonizing.rb

@@ -0,0 +1,112 @@
+require 'etc'
+require 'daemons'
+
+module Process
+  # Returns +true+ the process identied by +pid+ is running.
+  def running?(pid)
+    Process.getpgid(pid) != -1
+  rescue Errno::ESRCH
+    false
+  end
+  module_function :running?
+end
+
+module Thin
+  # Module included in classes that can be turned into a daemon.
+  # Handle stuff like:
+  # * storing the PID in a file
+  # * redirecting output to the log file
+  # * changing processs privileges
+  # * killing the process gracefully
+  module Daemonizable
+    attr_accessor :pid_file, :log_file
+    
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    def pid
+      File.exist?(pid_file) ? open(pid_file).read : nil
+    end
+    
+    # Turns the current script into a daemon process that detaches from the console.
+    def daemonize
+      check_plateform_support
+      raise ArgumentError, 'You must specify a pid_file to deamonize' unless @pid_file
+      
+      pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+      
+      Daemonize.daemonize(File.expand_path(@log_file))
+      
+      Dir.chdir(pwd)
+      
+      write_pid_file
+      at_exit do
+        log ">> Exiting!"
+        remove_pid_file
+      end
+    end
+    
+    # Change privileges of the process
+    # to the specified user and group.
+    def change_privilege(user, group=user)
+      check_plateform_support
+      log ">> Changing process privilege to #{user}:#{group}"
+      
+      uid, gid = Process.euid, Process.egid
+      target_uid = Etc.getpwnam(user).uid
+      target_gid = Etc.getgrnam(group).gid
+
+      if uid != target_uid || gid != target_gid
+        # Change process ownership
+        Process.initgroups(user, target_gid)
+        Process::GID.change_privilege(target_gid)
+        Process::UID.change_privilege(target_uid)
+      end
+    rescue Errno::EPERM => e
+      log "Couldn't change user and group to #{user}:#{group}: #{e}"
+    end
+    
+    module ClassMethods
+      # Kill the process which PID is stored in +pid_file+.
+      def kill(pid_file, timeout=60)
+        if pid = open(pid_file).read
+          pid = pid.to_i
+          print "Sending INT signal to process #{pid} ... "
+          begin
+            Process.kill('INT', pid)
+            Timeout.timeout(timeout) do
+              sleep 0.1 while Process.running?(pid)
+            end
+          rescue Timeout::Error
+            print "timeout, Sending KILL signal ... "
+            Process.kill('KILL', pid)
+          end
+          puts "stopped!"
+        else
+          puts "Can't stop process, no PID found in #{@pid_file}"
+        end
+      rescue Errno::ESRCH # No such process
+        puts "process not found!"
+      ensure
+        File.delete(pid_file) rescue nil
+      end
+    end
+    
+    private
+      def check_plateform_support
+        raise RuntimeError, 'Daemonizing not supported on Windows' if RUBY_PLATFORM =~ /mswin/
+      end
+      
+      def remove_pid_file
+        File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+      end
+      
+      def write_pid_file
+        log ">> Writing PID to #{@pid_file}"
+        FileUtils.mkdir_p File.dirname(@pid_file)
+        open(@pid_file,"w") { |f| f.write(Process.pid) }
+        File.chmod(0644, @pid_file)
+      end
+  end
+end