thin 0.3.0

data/lib/thin.rb

@@ -0,0 +1,19 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'fileutils'
+require 'timeout'
+require 'stringio'
+
+require 'thin/version'
+require 'thin/consts'
+require 'thin/statuses'
+require 'thin/mime_types'
+require 'thin/logging'
+require 'thin/daemonizing'
+require 'thin/server'
+require 'thin/request'
+require 'thin/headers'
+require 'thin/response'
+require 'thin/handler'
+require 'thin/cgi'
+require 'thin/rails'

data/lib/thin/cgi.rb

@@ -0,0 +1,159 @@
+require 'cgi'
+
+module Thin
+  # Class largely based on Mongrel::CGIWrapper
+  # http://mongrel.rubyforge.org by Zed A. Shaw <zedshaw at zedshaw dot com>
+  class CGIWrapper < ::CGI
+    public :env_table
+    attr_reader :options
+    # Set this to false if you want calls to CGIWrapper.out to not actually send
+    # the response until you force it.
+    attr_accessor :default_really_final
+
+    # these are stripped out of any keys passed to CGIWrapper.header function
+    REMOVED_KEYS = [ "nph","status","server","connection","type",
+                     "charset","length","language","expires"]
+
+    # Takes an HttpRequest and HttpResponse object, plus any additional arguments
+    # normally passed to CGI.  These are used internally to create a wrapper around
+    # the real CGI while maintaining Mongrel's view of the world.
+    def initialize(request, response, *args)
+      @request = request
+      @response = response
+      @args = *args
+      @input = request.body
+      @head = {}
+      @out_called = false
+      @default_really_final = true
+      super(*args)
+    end
+
+    # The header is typically called to send back the header.  In our case we
+    # collect it into a hash for later usage.
+    #
+    # nph -- Mostly ignored.  It'll output the date.
+    # connection -- Completely ignored.  Why is CGI doing this?
+    # length -- Ignored since Mongrel figures this out from what you write to output.
+    # 
+    def header(options = "text/html")
+      # if they pass in a string then just write the Content-Type
+      if options.class == String
+        @head['Content-Type'] = options unless @head['Content-Type']
+      else
+        # convert the given options into what Mongrel wants
+        @head['Content-Type'] = options['type'] || "text/html"
+        @head['Content-Type'] += "; charset=" + options['charset'] if options.has_key? "charset" if options['charset']
+
+        # setup date only if they use nph
+        @head['Date'] = CGI::rfc1123_date(Time.now) if options['nph']
+
+        # setup the server to use the default or what they set
+        @head['Server'] = options['server'] || env_table['SERVER_SOFTWARE']
+
+        # remaining possible options they can give
+        @head['Status'] = options['status'] if options['status']
+        @head['Content-Language'] = options['language'] if options['language']
+        @head['Expires'] = options['expires'] if options['expires']
+
+        # drop the keys we don't want anymore
+        REMOVED_KEYS.each {|k| options.delete(k) }
+
+        # finally just convert the rest raw (which puts 'cookie' directly)
+        # 'cookie' is translated later as we write the header out
+        options.each{|k,v| @head[k] = v}
+      end
+
+      # doing this fakes out the cgi library to think the headers are empty
+      # we then do the real headers in the out function call later
+      ""
+    end
+
+    # Takes any 'cookie' setting and sends it over the Mongrel header,
+    # then removes the setting from the options. If cookie is an 
+    # Array or Hash then it sends those on with .to_s, otherwise
+    # it just calls .to_s on it and hopefully your "cookie" can
+    # write itself correctly.
+    def send_cookies(to)
+      # convert the cookies based on the myriad of possible ways to set a cookie
+      if @head['cookie']
+        cookie = @head['cookie']
+        case cookie
+        when Array
+          cookie.each {|c| to['Set-Cookie'] = c.to_s }
+        when Hash
+          cookie.each_value {|c| to['Set-Cookie'] = c.to_s}
+        else
+          to['Set-Cookie'] = options['cookie'].to_s
+        end
+
+        @head.delete('cookie')
+      end
+
+      # @output_cookies seems to never be used, but we'll process it just in case
+      @output_cookies.each {|c| to['Set-Cookie'] = c.to_s } if @output_cookies
+    end
+
+    # The dumb thing is people can call header or this or both and in any order.
+    # So, we just reuse header and then finalize the HttpResponse the right way.
+    # Status is taken from the various options and converted to what Mongrel needs
+    # via the CGIWrapper.status function.
+    #
+    # We also prevent Rails from actually doing the final send by adding a
+    # second parameter "really_final".  Only Mongrel calls this after Rails
+    # is done.  Since this will break other frameworks, it defaults to 
+    # a different setting for rails (false) and (true) for others.
+    def out(options = "text/html", really_final=@default_really_final)
+      if @out_called || !really_final
+        # don't do it more than once or if it's not the really final call
+        return
+      end
+
+      header(options)
+
+      @response.start status do |head, body|
+        send_cookies(head)
+
+        @head.each {|k,v| head[k] = v}
+        body.write(yield || "")
+      end
+
+      @out_called = true
+    end
+
+    # Computes the status once, but lazily so that people who call header twice
+    # don't get penalized.  Because CGI insists on including the options status 
+    # message in the status we have to do a bit of parsing.
+    def status
+      if not @status
+        stat = @head["Status"]
+        stat = stat.split(' ')[0] if stat
+
+        @status = stat || "200"
+      end
+
+      @status
+    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.params
+    end
+
+    # Used to wrap the normal stdinput variable used inside CGI.
+    def stdinput
+      @input
+    end
+
+    # The stdoutput should be completely bypassed but we'll drop a warning just in case
+    def stdoutput
+      STDERR.puts "WARNING: Your program is doing something not expected.  Please tell Zed that stdoutput was used and what software you are running.  Thanks."
+      @response.body
+    end
+
+  end
+end

data/lib/thin/cluster.rb

@@ -0,0 +1,147 @@
+module Thin
+  # Control a set of servers. Generate start and stop commands and run them.
+  class Cluster
+    include Logging
+    
+    attr_accessor :environment, :log_file, :pid_file, :user, :group, :timeout
+    attr_reader   :address, :first_port, :size
+    
+    # Script to run
+    def self.thin=(value)
+      @@thin = value
+    end
+    @@thin = 'thin'
+    
+    # Create a new cluster of servers bound to +host+
+    # on ports +first_port+ to <tt>first_port + size - 1</tt>.
+    def initialize(dir, address, first_port, size)
+      @address    = address
+      @first_port = first_port
+      @size       = size
+      
+      @log_file   = 'thin.log'
+      @pid_file   = 'thin.pid'
+      
+      @timeout    = 60 # sec
+      
+      Dir.chdir dir if dir
+    end
+    
+    # Start the servers
+    def start
+      with_each_instance do |port|
+        start_on_port port
+      end
+    end
+    
+    # Start the server on a single port
+    def start_on_port(port)
+      logc "Starting #{address}:#{port} ... "
+      
+      run :start, :port        => port,
+                  :address     => @address,
+                  :environment => @environment,
+                  :daemonize   => true,
+                  :pid_file    => pid_file_for(port),
+                  :log_file    => log_file_for(port),
+                  :user        => @user,
+                  :group       => @group,
+                  :timeout     => @timeout,
+                  :trace       => @trace
+      
+      if wait_until_pid(:exist, port)
+        log "started in #{pid_for(port)}" if $?.success?
+      else
+        log 'failed to start'
+      end
+    end
+  
+    # Stop the servers
+    def stop
+      with_each_instance do |port|
+        stop_on_port port
+      end
+    end
+    
+    # Stop the server running on +port+
+    def stop_on_port(port)
+      logc "Stopping #{address}:#{port} ... "
+      
+      run :stop, :pid_file => pid_file_for(port),
+                 :timeout  => @timeout
+      
+      if wait_until_pid(!:exist, port)
+        log 'stopped' if $?.success?
+      else
+        log 'failed to stop'
+      end
+    end
+    
+    # Restart the servers one at the time.
+    # Prevent downtime by making sure only one is stopped at the time.
+    # See http://blog.carlmercier.com/2007/09/07/a-better-approach-to-restarting-a-mongrel-cluster/
+    def restart
+      with_each_instance do |port|
+        stop_on_port port
+        sleep 0.1 # Let the OS do his thang
+        start_on_port port
+      end
+    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={})
+        shell_cmd = shellify(cmd, options)
+        trace shell_cmd
+        `#{shell_cmd}`
+      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
+        "#{@@thin} #{cmd} #{shellified_options.compact.join(' ')}"
+      end
+      
+      # Wait for the pid file to be created (exist=true) of deleted (exist=false)
+      def wait_until_pid(exist, port)
+        Timeout.timeout(@timeout) do
+          sleep 0.1 until File.exist?(pid_file_for(port)) == !!exist
+        end
+        true
+      rescue Timeout::Error
+        false
+      end
+    
+      def with_each_instance
+        @size.times do |n|
+          port = @first_port + n
+          yield port
+        end
+      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/command.rb

@@ -0,0 +1,49 @@
+require 'transat/parser'
+
+module Thin
+  # Define a set of commands that can be parsed and executed.
+  # see bin/thin for an example.
+  def self.define_commands(&block)
+    begin
+      Transat::Parser.parse_and_execute(ARGV, &block)      
+    rescue CommandError => e
+      puts "Error: #{e}"
+    end
+  end
+  
+  # Raised when a command specific error happen.
+  class CommandError < StandardError; end
+  
+  # A command that can be runned from a command line script.
+  class Command
+    attr_reader :args
+  
+    def initialize(non_options, options)
+      @args = non_options
+
+      options.each do |option, value|
+        self.send("#{option}=", value)
+      end
+    end
+    
+    def self.command_name
+      self.name.match(/::(\w+)$/)[1].downcase
+    end
+    
+    def self.detailed_help
+      <<-EOF
+usage: #{File.basename($PROGRAM_NAME)} #{command_name}
+
+#{help}
+EOF
+    end
+    
+    protected
+      def error(message)
+        raise CommandError, message
+      end
+  end
+  
+  module Commands; end
+  Dir[File.dirname(__FILE__) + '/commands/**/*.rb'].each { |l| require l }
+end

data/lib/thin/commands/cluster/base.rb

@@ -0,0 +1,24 @@
+require 'thin/cluster'
+require 'yaml'
+
+module Thin::Commands::Cluster
+  class Base < Thin::Command
+    def self.config_attributes
+      [:address, :port, :environment, :log_file, :pid_file, :cwd, :servers, :user, :group]
+    end
+    
+    attr_accessor *self.config_attributes
+    attr_accessor :config, :trace
+    
+    protected
+      def load_from_config
+        return unless File.exist?(config)
+        
+        hash = File.open(config) { |file| YAML.load(file) }
+        
+        self.class.config_attributes.each do |attr|
+          send "#{attr}=", hash[attr.to_s]
+        end
+      end
+  end
+end

data/lib/thin/commands/cluster/config.rb

@@ -0,0 +1,34 @@
+module Thin::Commands::Cluster
+  class Config < Base
+    def run
+      error 'Config file required' unless config
+      
+      Dir.chdir cwd if cwd
+      
+      hash = {}
+      self.class.config_attributes.each do |attr|
+        hash[attr.to_s] = send(attr)
+      end
+      
+      File.open(config, 'w') { |f| f << YAML.dump(hash) }
+    end
+
+    def self.help
+      "Create a thin_cluster configuration file."
+    end
+    
+    def self.detailed_help
+      <<-EOF
+usage: thin_cluster config [options]
+
+  Create a configuration file for thin_cluster.
+  
+  All the options passed to this command will be stored
+  in <config> in YAML format.
+  
+  You can then use this configuration file with the start,
+  stop and restart commands with the --config option.
+EOF
+    end
+  end
+end

data/lib/thin/commands/cluster/restart.rb

@@ -0,0 +1,35 @@
+module Thin::Commands::Cluster
+  class Restart < Base
+    def run
+      load_from_config
+      
+      cluster = Thin::Cluster.new(cwd, address, port, servers)
+
+      cluster.log_file = log_file
+      cluster.pid_file = pid_file
+      cluster.trace    = trace
+      cluster.user     = user
+      cluster.group    = group
+      
+      cluster.restart
+    end
+
+    def self.help
+      "Restart servers"
+    end
+
+    def self.detailed_help
+      <<-EOF
+usage: thin_cluster restart [options]
+
+  Restart the servers one at the time.
+  Prevent downtime by making sure only one is stopped at the time.
+  
+  For example, first server is stopped, then started. When the first
+  server is fully started the second one is stopped ...
+  
+  See http://blog.carlmercier.com/2007/09/07/a-better-approach-to-restarting-a-mongrel-cluster/
+EOF
+    end
+  end
+end