thin 0.6.2 → 0.6.3

data/CHANGELOG

@@ -1,3 +1,37 @@
+== 0.6.3 Ninja Cookie release
+ * 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].
+ * Add support for specifying a custom Connector to the server and add more doc about Server
+   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.
+ * Make sure chdir option from config file is used when present.
+ * Raise an error when starting a server as a daemon and pid file already exist, fixes #27.
+
 == 0.6.2 Rambo release
  * Server now let current connections finish before stopping, fixes #18
  * Fix uploading hanging bug when body is moved to a tempfile,

data/bin/thin

@@ -1,168 +1,6 @@
 #!/usr/bin/env ruby
-# <tt>thin start</tt>: Starts the Rails app in the current directory.
+# Thin command line interface script.
 # Run <tt>thin -h</tt> to get more usage.
 require File.dirname(__FILE__) + '/../lib/thin'
-require 'optparse'
-require 'yaml'
 
-COMMANDS = %w(start stop restart config)
-
-# Default options values
-options = {
-  :chdir       => Dir.pwd,
-  :environment => 'development',
-  :address     => '0.0.0.0',
-  :port        => 3000,
-  :timeout     => 60,
-  :log         => 'log/thin.log',
-  :pid         => 'tmp/pids/thin.pid',
-  :servers     => 1 # no cluster
-}
-
-# NOTE: If you add an option here make sure the key in the +options+ hash is the
-# same as the name of the command line option.
-# +option+ keys are use to build the command line to launch a cluster,
-# see <tt>lib/thin/cluster.rb</tt>.
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: thin [options] #{COMMANDS.join('|')}"
-
-  opts.separator ""
-  opts.separator "Server options:"
-
-  opts.on("-a", "--address HOST", "bind to HOST address (default: 0.0.0.0)")      { |host| options[:address] = host }
-  opts.on("-p", "--port PORT", "use PORT (default: 3000)")                        { |port| options[:port] = port.to_i }
-  opts.on("-S", "--socket PATH", "bind to unix domain socket")                    { |file| options[:socket] = file }
-  opts.on("-e", "--environment ENV", "Rails environment (default: development)")  { |env| options[:environment] = env }
-  opts.on("-c", "--chdir PATH", "Change to dir before starting")                  { |dir| options[:chdir] = File.expand_path(dir) }
-  opts.on("-t", "--timeout SEC", "Request or command timeout in sec",            
-                                 "(default: #{options[:timeout]})")               { |sec| options[:timeout] = sec.to_i }
-  opts.on(      "--prefix PATH", "Mount the app under PATH (start with /)")       { |path| options[:prefix] = path }
-  opts.on(      "--stats PATH", "Mount the Stats adapter under PATH")             { |path| options[:stats] = path }
-
-  opts.separator ""
-  opts.separator "Daemon options:"
-  
-  opts.on("-d", "--daemonize", "Run daemonized in the background")                { options[:daemonize] = true }
-  opts.on("-l", "--log FILE", "File to redirect output",
-                              "(default: #{options[:log]})")                      { |file| options[:log] = file }
-  opts.on("-P", "--pid FILE", "File to store PID",
-                              "(default: #{options[:pid]})")                      { |file| options[:pid] = file }
-  opts.on("-u", "--user NAME", "User to run daemon as (use with -g)")             { |user| options[:user] = user }
-  opts.on("-g", "--group NAME", "Group to run daemon as (use with -u)")           { |group| options[:group] = group }
-  
-  opts.separator ""
-  opts.separator "Cluster options:"
-  
-  opts.on("-s", "--servers NUM", "Number of servers to start",
-                                 "set a value >1 to start a cluster")             { |num| options[:servers] = num.to_i }
-  opts.on("-o", "--only NUM", "Send command to only one server of the cluster")   { |only| options[:only] = only }
-  opts.on("-C", "--config PATH", "Load options from a config file")               { |file| options[:config] = file }
-  
-  opts.separator ""
-  opts.separator "Common options:"
-
-  opts.on_tail("-D", "--debug", "Set debbuging on")       { $DEBUG = true }
-  opts.on_tail("-V", "--trace", "Set tracing on")         { $TRACE = true }
-  opts.on_tail("-h", "--help", "Show this message")       { puts opts; exit }
-  opts.on_tail('-v', '--version', "Show version")         { puts Thin::SERVER; exit }
-end
-
-
-# == Utilities
-
-def cluster?(options)
-  options[:only] || (options[:servers] && options[:servers] > 1)
-end
-
-def load_options_from_config_file!(options)
-  if file = options.delete(:config)
-    YAML.load_file(file).each { |key, value| options[key.to_sym] = value }
-  end
-end
-
-
-# == Commands definitions
-
-def start(options)
-  load_options_from_config_file! options
-  
-  if cluster?(options)
-    Thin::Cluster.new(options).start
-  else
-    if options[:socket]
-      server = Thin::Server.new(options[:socket])
-    else
-      server = Thin::Server.new(options[:address], options[:port])
-    end
-  
-    server.pid_file = options[:pid]
-    server.log_file = options[:log]
-    server.timeout  = options[:timeout]
-  
-    if options[:daemonize]
-      server.daemonize
-      server.change_privilege options[:user], options[:group] if options[:user] && options[:group]
-    end
-  
-    server.app = Rack::Adapter::Rails.new(options.merge(:root => options[:chdir]))
-    
-    # If a prefix is required, wrap in Rack URL mapper
-    server.app = Rack::URLMap.new(options[:prefix] => server.app) if options[:prefix]
-    
-    # If a stats are required, wrap in Stats adapter
-    server.app = Thin::Stats::Adapter.new(server.app, options[:stats]) if options[:stats]
-    
-    # Register restart procedure
-    server.on_restart { Thin::Command.run(:start, options) }
-    
-    server.start
-  end  
-end
-
-def stop(options)
-  load_options_from_config_file! options
-  
-  if cluster?(options)
-    Thin::Cluster.new(options).stop
-  else
-    Thin::Server.kill(options[:pid], options[:timeout])
-  end
-end
-
-def restart(options)
-  load_options_from_config_file! options
-  
-  if cluster?(options)
-    Thin::Cluster.new(options).restart
-  else
-    Thin::Server.restart(options[:pid])
-  end
-end
-
-def config(options)
-  config_file = options.delete(:config) || abort('config option required')
-
-  # Stringify keys
-  options.keys.each { |o| options[o.to_s] = options.delete(o) }
-
-  File.open(config_file, 'w') { |f| f << options.to_yaml }
-  puts "Wrote configuration to #{config_file}"
-end
-
-
-# == Runs the command
-
-opts.parse! ARGV
-command = ARGV[0]
-
-Dir.chdir(options[:chdir])
-
-if COMMANDS.include?(command)
-  send(command, options)
-elsif command.nil?
-  puts "Command required"
-  puts opts
-  exit 1  
-else
-  abort "Invalid command : #{command}"
-end
+Thin::Runner.new(ARGV).run!

data/example/config.ru

@@ -1,5 +1,8 @@
 # Run with: rackup -s thin
-# Then browse to http://localhost:9292
+# then browse to http://localhost:9292
+# Or with: thin start -r config.ru
+# then browse to http://localhost:3000
+# 
 # Check Rack::Builder doc for more details on this file format:
 #  http://rack.rubyforge.org/doc/classes/Rack/Builder.html
 

data/example/ramaze.ru

@@ -0,0 +1,12 @@
+# Ramaze Rackup config file.
+# by tmm1
+# Use with --rackup option:
+# 
+#   thin start -r ramaze.ru
+# 
+require 'start'
+
+Ramaze.trait[:essentials].delete Ramaze::Adapter
+Ramaze.start :force => true
+
+run Ramaze::Adapter::Base

data/example/thin.god

@@ -1,72 +1,76 @@
-# WARNING: this config file has not been tested yet.
-# If you know God better then I, feel free to tweak it and send it to me.
-# Thanks!
-# -- Marc
+# == God config file
+# http://god.rubyforge.org/
+# Author: Gump
+#
+# Config file for god that configures watches for each instance of a thin server for
+# each thin configuration file found in /etc/thin.
+# In order to get it working on Ubuntu, I had to make a change to god as noted at
+# the following blog:
+# http://blog.alexgirard.com/2007/10/25/ruby-one-line-to-save-god/
+#
+require 'yaml'
 
-RAILS_ROOT = "/Users/marc/projects/refactormycode"
+config_path = "/etc/thin"
 
-God.watch do |w|
-  w.name = "thin-3000"
-  w.group = 'thins'
-  w.interval = 5.seconds # default
-  w.start = "thin start -c #{RAILS_ROOT} -P #{RAILS_ROOT}/tmp/pids/thin.3000.pid -p 3000 -d"
-  w.stop = "thin stop -P #{RAILS_ROOT}/tmp/pids/thin.3000.pid"
-  w.restart = "thin restart -P #{RAILS_ROOT}/tmp/pids/thin.3000.pid -p 3000"
-  w.pid_file = File.join(RAILS_ROOT, "tmp/pids/thin.3000.pid")
-  
-  # clean pid files before start if necessary
-  w.behavior(:clean_pid_file)
-  
-  # determine the state on startup
-  w.transition(:init, { true => :up, false => :start }) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-    end
-  end
-  
-  # determine when process has finished starting
-  w.transition([:start, :restart], :up) do |on|
-    on.condition(:process_running) do |c|
-      c.running = true
-    end
-    
-    # failsafe
-    on.condition(:tries) do |c|
-      c.times = 5
-      c.transition = :start
-    end
-  end
+Dir[config_path + "/*.yml"].each do |file|
+  config = YAML.load_file(file)
+  num_servers = config["servers"] ||= 1
 
-  # start if process is not running
-  w.transition(:up, :start) do |on|
-    on.condition(:process_exits)
-  end
-  
-  # restart if memory or cpu is too high
-  w.transition(:up, :restart) do |on|
-    on.condition(:memory_usage) do |c|
-      c.interval = 20
-      c.above = 50.megabytes
-      c.times = [3, 5]
-    end
-    
-    on.condition(:cpu_usage) do |c|
-      c.interval = 10
-      c.above = 10.percent
-      c.times = [3, 5]
-    end
-  end
-  
-  # lifecycle
-  w.lifecycle do |on|
-    on.condition(:flapping) do |c|
-      c.to_state = [:start, :restart]
-      c.times = 5
-      c.within = 5.minute
-      c.transition = :unmonitored
-      c.retry_in = 10.minutes
-      c.retry_times = 5
-      c.retry_within = 2.hours
+  for i in 0...num_servers
+    God.watch do |w|
+      w.group = "thin-" + File.basename(file, ".yml")
+      w.name = w.group + "-#{i}"
+      
+      w.interval = 30.seconds
+      
+      w.uid = config["user"]
+      w.gid = config["group"]
+      
+      w.start = "thin start -C #{file} -o #{i}"
+      w.start_grace = 10.seconds
+      
+      w.stop = "thin stop -C #{file} -o #{i}"
+      w.stop_grace = 10.seconds
+      
+      w.restart = "thin restart -C #{file} -o #{i}"
+
+      pid_path = config["chdir"] + "/" + config["pid"]
+      ext = File.extname(pid_path)
+
+      w.pid_file = pid_path.gsub(/#{ext}$/, ".#{i}#{ext}")
+      
+      w.behavior(:clean_pid_file)
+
+      w.start_if do |start|
+        start.condition(:process_running) do |c|
+          c.interval = 5.seconds
+          c.running = false
+        end
+      end
+
+      w.restart_if do |restart|
+        restart.condition(:memory_usage) do |c|
+          c.above = 150.megabytes
+          c.times = [3,5] # 3 out of 5 intervals
+        end
+
+        restart.condition(:cpu_usage) do |c|
+          c.above = 50.percent
+          c.times = 5
+        end
+      end
+
+      w.lifecycle do |on|
+        on.condition(:flapping) do |c|
+          c.to_state = [:start, :restart]
+          c.times = 5
+          c.within = 5.minutes
+          c.transition = :unmonitored
+          c.retry_in = 10.minutes
+          c.retry_times = 5
+          c.retry_within = 2.hours
+        end
+      end
     end
   end
 end

data/example/vlad.rake

@@ -0,0 +1,61 @@
+# $GEM_HOME/gems/vlad-1.2.0/lib/vlad/thin.rb
+# Thin tasks for Vlad the Deployer
+# By cnantais
+require 'vlad'
+
+namespace :vlad do
+  ##
+  # Thin app server
+
+  set :thin_address,       "127.0.0.1"
+  set :thin_command,       'thin'
+  set(:thin_conf)          { "#{shared_path}/thin_cluster.conf" }
+  set :thin_environment,   "production"
+  set :thin_group,         nil
+  set :thin_log_file,      nil
+  set :thin_pid_file,      nil
+  set :thin_port,          nil
+  set :thin_socket,        "/tmp/thin.sock"
+  set :thin_prefix,        nil
+  set :thin_servers,       2
+  set :thin_user,          nil
+
+  desc "Prepares application servers for deployment. thin
+configuration is set via the thin_* variables.".cleanup
+
+  remote_task :setup_app, :roles => :app do
+    cmd = [
+           "#{thin_command} config",
+           "-s #{thin_servers}",
+           "-S #{thin_socket}",
+           "-e #{thin_environment}",
+           "-a #{thin_address}",
+           "-c #{current_path}",
+           "-C #{thin_conf}",
+           ("-P #{thin_pid_file}" if thin_pid_file),
+           ("-l #{thin_log_file}" if thin_log_file),
+           ("--user #{thin_user}" if thin_user),
+           ("--group #{thin_group}" if thin_group),
+           ("--prefix #{thin_prefix}" if thin_prefix),
+           ("-p #{thin_port}" if thin_port),
+          ].compact.join ' '
+
+    run cmd
+  end
+
+  def thin(cmd) # :nodoc:
+    "#{thin_command} #{cmd} -C #{thin_conf}"
+  end
+
+  desc "Restart the app servers"
+
+  remote_task :start_app, :roles => :app do
+    run thin("restart -s #{thin_servers}")
+  end
+
+  desc "Stop the app servers"
+
+  remote_task :stop_app, :roles => :app do
+    run thin("stop -s #{thin_servers}")
+  end
+end

data/lib/rack/adapter/rails.rb

@@ -1,6 +1,3 @@
-# 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.

data/lib/rack/handler/thin.rb

@@ -1,12 +1,17 @@
 module Rack
   module Handler
+    # Rack Handler stricly to be able to use Thin through the rackup command.
+    # To do so, simply require 'thin' in your Rack config file and run like this
+    # 
+    #   rackup --server thin
+    # 
     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!
+        server.start
       end
     end
   end