thin 0.5.0 → 0.5.2

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Marc-Andre Cournoyer
+Copyright (c) 2008 Marc-Andre Cournoyer
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README

@@ -19,13 +19,9 @@ or using my mirror (might be more recent):
 
 Or from source:
 
- git clone http://code.macournoyer.com/git/thin.git
+ git clone git://repo.or.cz/thin.git
  cd thin
  rake install
- 
-Or from the Subversion mirror (might be out of date):
-
- svn co http://code.macournoyer.com/svn/thin/trunk thin
 
 === Usage
 A +thin+ script is offered to easily start your Rails application:
@@ -60,5 +56,5 @@ either the terms of the GPL.
 
 Thin is copyright Marc-Andre Cournoyer <macournoyer@gmail.com>
 
-Please report any bug at http://code.macournoyer.com/thin/trac.fcgi/newticket
-and security issues directly to me at macournoyer@gmail.com.
+Please report any bug at http://groups.google.com/group/thin-ruby/
+and major security issues directly to me at macournoyer@gmail.com.

data/Rakefile

@@ -1,174 +1,17 @@
+RUBY_1_9 = RUBY_VERSION =~ /^1\.9/
+
 require 'rake'
 require 'rake/clean'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'spec/rake/spectask'
-
-require File.dirname(__FILE__) + '/lib/thin'
+require 'lib/thin'
+Dir['tasks/**/*.rake'].each { |rake| load rake }
 
-EXT_DIR    = 'ext/thin_parser'
-EXT_BUNDLE = "#{EXT_DIR}/thin_parser.#{Config::CONFIG['DLEXT']}"
-EXT_FILES  = FileList[
-  "#{EXT_DIR}/*.c",
-  "#{EXT_DIR}/*.h",
-  "#{EXT_DIR}/*.rl",
-  "#{EXT_DIR}/extconf.rb",
-  "#{EXT_DIR}/Makefile",
-  "lib"
-]
-CLEAN.include %w(doc/rdoc pkg coverage tmp log *.gem **/*.{o,bundle,jar,so,obj,pdb,lib,def,exp,log} ext/*/Makefile ext/*/conftest.dSYM)
-
-desc "Run all examples"
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = FileList['spec/**/*.rb']
-end
 task :default => [:compile, :spec]
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'doc/rdoc'
-  rdoc.options += ['--quiet', '--title', Thin::NAME,
-             	     "--opname", "index.html",
-            	     "--line-numbers",
-            	     "--main", "README",
-            	     "--inline-source"]
-  rdoc.template = "site/rdoc.rb"
-  rdoc.main = "README"
-  rdoc.title = Thin::NAME
-  rdoc.rdoc_files.add %w(README lib/thin/*.rb')
-end
-
-namespace :rdoc do
-  desc 'Upload rdoc to code.macournoyer.com'
-  task :upload => :rdoc do
-    upload "doc/rdoc", 'thin/doc', :replace => true
-  end
-end
-
-spec = Gem::Specification.new do |s|
-  s.name                  = Thin::NAME
-  s.version               = Thin::VERSION::STRING
-  s.platform              = Gem::Platform::RUBY
-  s.summary               = 
-  s.description           = "A thin and fast web server"
-  s.author                = "Marc-Andre Cournoyer"
-  s.email                 = 'macournoyer@gmail.com'
-  s.homepage              = 'http://code.macournoyer.com/thin/'
-  s.executables           = %w(thin)
-
-  s.required_ruby_version = '>= 1.8.6'
-  
-  s.add_dependency        'eventmachine', '>= 0.9.0'
-  s.add_dependency        'rack',         '>= 0.2.0'
-
-  s.files                 = %w(COPYING README Rakefile) +
-                            Dir.glob("{bin,doc,spec,lib,example}/**/*") + 
-                            Dir.glob("ext/**/*.{h,c,rb,rl}") +
-  s.extensions            = FileList["ext/**/extconf.rb"].to_a
-  
-  s.require_path          = "lib"
-  s.bindir                = "bin"
-end
-
-Rake::GemPackageTask.new(spec) do |p|
-  p.gem_spec = spec
-end
-
-namespace :gem do
-  desc 'Upload gem to code.macournoyer.com'
-  task :upload => :gem do
-    upload "pkg/#{spec.full_name}.gem", 'gems'
-    sh 'ssh macournoyer@macournoyer.com "cd code.macournoyer.com && index_gem_repository.rb"'
-  end
-  
-  desc 'Upload gem to rubyforge.org'
-  task :upload_rubyforge => :gem do
-    sh 'rubyforge login'
-    sh "rubyforge add_release thin thin #{Thin::VERSION::STRING} pkg/thin-#{Thin::VERSION::STRING}.gem"
-    sh "rubyforge add_file thin thin #{Thin::VERSION::STRING} pkg/thin-#{Thin::VERSION::STRING}.gem"
-  end
-end
-
-task :ragel do
-  Dir.chdir EXT_DIR do
-    target = "parser.c"
-    File.unlink target if File.exist? target
-    sh "ragel parser.rl | rlgen-cd -G2 -o #{target}"
-    raise "Failed to compile Ragel state machine" unless File.exist? target
-  end
-end
-  
-desc "Compile the extensions"
-task :compile => ["#{EXT_DIR}/Makefile", EXT_BUNDLE]
-
-task :package => :compile
-
-file "#{EXT_DIR}/Makefile" => ["#{EXT_DIR}/extconf.rb"] do
-  cd(EXT_DIR) { ruby "extconf.rb" }
-end
-
-file EXT_BUNDLE => EXT_FILES do
-  cd EXT_DIR do
-    sh(PLATFORM =~ /win32/ ? 'nmake' : 'make')
-  end
-  cp EXT_BUNDLE, 'lib/'
-end
-
-desc 'Show some stats about the code'
-task :stats do
-  line_count = proc do |path|
-    Dir[path].collect { |f| File.open(f).readlines.reject { |l| l =~ /(^\s*(\#|\/\*))|^\s*$/ }.size }.inject(0){ |sum,n| sum += n }
-  end
-  lib = line_count['lib/**/*.rb']
-  ext = line_count['ext/**/*.{c,h}'] 
-  test = line_count['test/**/*.rb']
-  ratio = '%1.2f' % (test.to_f / lib.to_f)
-  
-  puts "#{lib.to_s.rjust(6)} LOC of lib"
-  puts "#{ext.to_s.rjust(6)} LOC of ext"
-  puts "#{test.to_s.rjust(6)} LOC of test"
-  puts "#{ratio.to_s.rjust(6)} ratio lib/test"
-end
-
-namespace :site do
-  task :build do
-    mkdir_p 'tmp/site/images'
-    cd 'tmp/site' do
-      ruby '../../site/thin.rb', '--dump'
-    end
-    cp 'site/style.css', 'tmp/site'
-    cp_r Dir['site/images/*'], 'tmp/site/images'
-  end
-  
-  desc 'Upload website to code.macournoyer.com'
-  task :upload => 'site:build' do
-    upload 'tmp/site/*', 'thin'
-  end
-end
-
-namespace :deploy do
-  task :site => %w(site:upload rdoc:upload)
-  
-  desc 'Deploy on code.macournoyer.com'
-  task :alpha => %w(gem:upload deploy:site)
-  
-  desc 'Deploy on rubyforge'
-  task :public => %w(gem:upload_rubyforge deploy:site)  
-end
-desc 'Deploy on all servers'
-task :deploy => %w(deploy:alpha deploy:public)
-
 task :install => :compile do
   sh %{rake package}
-  sh %{sudo gem install pkg/#{Thin::NAME}-#{Thin::VERSION::STRING}}
+  sh %{sudo #{gem} install pkg/#{Thin::NAME}-#{Thin::VERSION::STRING}}
 end
 
 task :uninstall => :clean do
-  sh %{sudo gem uninstall #{Thin::NAME}}
+  sh %{sudo #{gem} uninstall #{Thin::NAME}}
 end
-
-# == Utilities
-
-def upload(file, to, options={})
-  sh %{ssh macournoyer@macournoyer.com "rm -rf code.macournoyer.com/#{to}"} if options[:replace]
-  sh %{scp -rq #{file} macournoyer@macournoyer.com:code.macournoyer.com/#{to}}
-end

data/bin/thin

@@ -1,79 +1,118 @@
 #!/usr/bin/env ruby
+# <tt>thin start</tt>: Starts the Rails app in the current directory.
+# Run <tt>thin -h</tt> to get more usage.
 require File.dirname(__FILE__) + '/../lib/thin'
 require 'optparse'
 
+COMMANDS = %w(start stop restart)
+
+# Default options values
 options = {
-  :root     => Dir.pwd,
-  :env      => 'development',
-  :host     => '0.0.0.0',
-  :port     => 3000,
-  :timeout  => 60,
-  :log_file => 'log/thin.log',
-  :pid_file => 'tmp/pids/thin.pid'
+  :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] start|stop"
+  opts.banner = "Usage: thin [options] #{COMMANDS.join('|')}"
 
   opts.separator ""
   opts.separator "Server options:"
 
-  opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)")      { |host| options[:host] = host }
-  opts.on("-p", "--port PORT", "use PORT (default: 3000)")               { |port| options[:port] = port }
-  opts.on("-e", "--env ENV", "Rails environment (default: development)") { |env| options[:env] = env }
-  opts.on("-c", "--chdir PATH", "listen on HOST (default: current dir)") { |dir| options[:root] = dir }
-  opts.on("-d", "--daemonize", "Daemonize")                              { options[:daemonize] = true }
-  opts.on("-l", "--log-file FILE", "File to redirect output",
-                                   "(default: #{options[:log_file]})")   { |file| options[:log_file] = file }
-  opts.on("-P", "--pid-file FILE", "File to store PID",
-                                   "(default: #{options[:pid_file]})")   { |file| options[:pid_file] = file }
-  opts.on("-t", "--timeout SEC", "Request or command timeout in sec",    
-                                 "(default: #{options[:timeout]})")      { |sec| options[:timeout] = sec }
-  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.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("-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("-s", "--servers NUM", "Number of servers to start",
+                                 "set a value >1 to start a cluster")             { |num| options[:servers] = num.to_i }
+  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("-t", "--timeout SEC", "Request or command timeout in sec",            
+                                 "(default: #{options[:timeout]})")               { |sec| options[:timeout] = sec.to_i }
+  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 "Common options:"
 
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-
-  opts.on_tail('-v', '--version', "Show version") do
-    puts Thin::NAME
-    exit
-  end
+  opts.on_tail("-D", "--debug", "Set debbuging on") { $DEBUG = true }
+  opts.on_tail("-h", "--help", "Show this message") { puts opts; exit }
+  opts.on_tail('-v', '--version', "Show version")   { puts Thin::SERVER; exit }
 
   opts.parse! ARGV
 end
 
-case ARGV[0]
+
+# == Commands definitions
+
+def cluster?(options)
+  options[:servers] && options[:servers] > 1
+end
+
+def start(options)
+  if cluster?(options)
+    Thin::Cluster.new(options).start
+  else
+    server = Thin::Server.new(options[:address], options[:port])
+  
+    server.pid_file = options[:pid]
+    server.log_file = options[:log]
+    server.timeout  = options[:timeout]
   
-when 'start'
-  app = Rack::Adapter::Rails.new(options)
-  server = Thin::Server.new(options[:host], options[:port], app)
+    if options[:daemonize]
+      server.change_privilege options[:user], options[:group] if options[:user] && options[:group]
+      server.daemonize
+    end
   
-  server.pid_file = options[:pid_file]
-  server.log_file = options[:log_file]
-  server.timeout  = options[:timeout]
+    server.app = Rack::Adapter::Rails.new(options.merge(:root => options[:chdir]))
+    server.start!
+  end  
+end
+
+def stop(options)
+  if cluster?(options)
+    Thin::Cluster.new(options).stop
+  else
+    Thin::Server.kill options[:pid], options[:timeout]
+  end
+end
+
+def restart(options)
+  if cluster?(options)
+    Thin::Cluster.new(options).restart
+  else
+    # Restart only make sense when running as a daemon
+    options.update :daemonize => true
   
-  if options[:daemonize]
-    server.change_privilege options[:user], options[:group] if options[:user] && options[:group]
-    server.daemonize
+    stop(options)
+    start(options)
   end
+end
+
 
-  server.start!
+# == Runs the command
 
-when 'stop'
-  Thin::Server.kill options[:pid_file], options[:timeout]
+Dir.chdir(options[:chdir])
+command = ARGV[0]
 
-when nil
+if COMMANDS.include?(command)
+  send(command, options)
+elsif command.nil?
   puts "Command required"
   puts opts
-  exit 1
-  
+  exit 1  
 else
-  abort "Invalid command : #{ARGV[0]}"
-  
+  abort "Invalid command : #{command}"
 end

data/example/thin.god

@@ -0,0 +1,72 @@
+# 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
+
+RAILS_ROOT = "/Users/marc/projects/refactormycode"
+
+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
+
+  # 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
+    end
+  end
+end