mongrel 0.3.6 → 0.3.7

data/README

@@ -14,7 +14,8 @@ scream without too many portability issues.
 The 0.3.6 release supports Ruby On Rails much better than previously, and also
 sports the beginning of a command and plugin infrastructure.  There is now a more
 complete CGIWrapper that handles most of the CGI usage, but still doesn't do the
-MIME decoding or file upload/send (it leaves that to CGI).
+MIME decoding or file upload/send (it leaves that to CGI).  Finally, there's a
+great mongrel_rails_service script for running under Win32 as a service.
 
 After you've installed (either with gem install mongrel or via source) you should
 have the mongrel_rails command available in your PATH.  Then you just do the following:
@@ -42,6 +43,32 @@ There are also many more new options for configuring the rails runner including
 changing to a different directory, adding more MIME types, and setting processor
 threads and timeouts.
 
+
+=== Win32 Service Support
+
+Mongrel now has support for running as a Win32 service right out of the
+box.  The support is still rough but works well enough that we decided
+to release it.  You can thank Luis Lavena for working on this and making
+it so nice.
+
+After you do the gem install, find a Rails application you want to run
+and do:
+
+ $ mongrel_rails_service install -n myapp \ 
+     -r c:\my\path\to\myapp -p 4000 -e production
+ $ mongrel_rails_service start -n myapp
+
+Now hit the port and poof, works.  *Stopping the service is a little problematic right now.*
+
+If you run into an app that's not running right, my suggestion is to run it with
+the regular mongrel_rails runner:
+
+ $ cd c:\my\path\to\myapp
+ $ mongrel_rails start -p 4500
+
+Since that will spit out error messages and stuff to the console.  *Use CTRL-Pause/Break to stop.*
+
+
 == Install
 
 It doesn't explicitly require Camping, but if you want to run the examples/camping/

data/Rakefile

@@ -30,7 +30,7 @@ end
 
 setup_extension("http11", "http11")
 
-version="0.3.6"
+version="0.3.7"
 summary = "A small fast HTTP library and server that runs Rails, Camping, and Nitro apps."
 test_file = "test/test_ws.rb"
 author="Zed A. Shaw"
@@ -44,7 +44,7 @@ end
 desc "Build a binary gem for Win32"
 task :win32_gem => [:clean, :compile, :test, :rerdoc, :package_win32]
 
-scripts_win32 = scripts + ['mongrel_rails_service','mongrel_rails_svc']
+scripts_win32 = scripts + ['mongrel_rails_service']
 task :package_win32 do
   setup_win32_gem(name, version,  version, summary, scripts_win32, test_file) do |spec|
     spec.add_dependency('win32-service', '>= 0.5.0')

data/bin/mongrel_rails

@@ -1,61 +1,24 @@
 require 'rubygems'
-require 'mongrel'
-require 'mongrel/command'
+require 'mongrel/rails'
 
 
-class RailsHandler < Mongrel::HttpHandler
-
-  def initialize(dir, mime_map = {})
-    @files = Mongrel::DirHandler.new(dir,false)
-    @guard = Mutex.new
-    
-    # register the requested mime types
-    mime_map.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
-  end
-  
-  def process(request, response)
-    # not static, need to talk to rails
-    return if response.socket.closed?
-
-    if @files.can_serve(request.params["PATH_INFO"])
-      @files.process(request,response)
-    else
-      cgi = Mongrel::CGIWrapper.new(request, response)
-
-      begin
-        @guard.synchronize do
-          # Rails is not thread safe so must be run entirely within synchronize 
-          Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
-        end
-
-        # This finalizes the output using the proper HttpResponse way
-        cgi.out {""}
-      rescue Object => rails_error
-        STDERR.puts "calling Dispatcher.dispatch #{rails_error}"
-        STDERR.puts rails_error.backtrace.join("\n")
-      end
-    end
-
-  end
-end
-
-
-
-class StartCommand < Mongrel::Command::Command
+class Start < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
 
   def configure
     options [
-             ["-e", "--environment ENV", "Rails environment to run as", :@environment, ENV['RAILS_ENV'] || "development"],
-             ["-d", "--daemonize", "Whether to run in the background or not", :@daemon, false],
-             ['-p', '--port PORT', "Which port to bind to", :@port, 3000],
-             ['-a', '--address ADDR', "Address to bind to", :@address, "0.0.0.0"],
-             ['-l', '--log FILE', "Where to write log messages", :@log_file, "log/mongrel.log"],
-             ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "log/mongrel.pid"],
-             ['-n', '--num-procs INT', "Number of processor threads to use", :@num_procs, 20],
-             ['-t', '--timeout SECONDS', "Timeout all requests after SECONDS time", :@timeout, 120],
-             ['-m', '--mime PATH', "A YAML file that lists additional MIME types", :@mime_map, nil],
-             ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, Dir.pwd],
-             ['-r', '--root PATH', "Set the document root (default 'public')", :@docroot, "public"],
+      ["-e", "--environment ENV", "Rails environment to run as", :@environment, ENV['RAILS_ENV'] || "development"],
+      ["-d", "--daemonize", "Whether to run in the background or not", :@daemon, false],
+      ['-p', '--port PORT', "Which port to bind to", :@port, 3000],
+      ['-a', '--address ADDR', "Address to bind to", :@address, "0.0.0.0"],
+      ['-l', '--log FILE', "Where to write log messages", :@log_file, "log/mongrel.log"],
+      ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "log/mongrel.pid"],
+      ['-n', '--num-procs INT', "Number of processor threads to use", :@num_procs, 20],
+      ['-t', '--timeout SECONDS', "Timeout all requests after SECONDS time", :@timeout, 120],
+      ['-m', '--mime PATH', "A YAML file that lists additional MIME types", :@mime_map, nil],
+      ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, Dir.pwd],
+      ['-r', '--root PATH', "Set the document root (default 'public')", :@docroot, "public"],
+      ['-L', '--load PATH', "Loads plugins from the given directory", :@load_from, nil],
     ]
   end
   
@@ -71,9 +34,12 @@ class StartCommand < Mongrel::Command::Command
     valid_dir? @docroot, "Path to docroot not valid: #@docroot"
     valid_exists? @mime_map, "MIME mapping file does not exist: #@mime_map" if @mime_map
 
+    valid_dir? @load_from, "Plugin directory path does not exist" if @load_from
+
     return @valid
   end
 
+
   def daemonize 
     # save this for later since daemonize will hose it
     if @daemon and RUBY_PLATFORM !~ /mswin/
@@ -117,22 +83,47 @@ class StartCommand < Mongrel::Command::Command
   end
 
   def start_mongrel(rails)
-    # start up mongrel with the right configurations
+    @restart = false
+
     server = Mongrel::HttpServer.new(@address, @port, @num_procs.to_i, @timeout.to_i)
     server.register("/", rails)
     server.run
-    trap("INT") { server.stop }
+
+    # signal trapping just applies to posix systems
+    # TERM is a valid signal, but still doesn't gracefuly shutdown on win32.
+    if RUBY_PLATFORM !~ /mswin/
+      # graceful shutdown
+      trap("TERM") { 
+        server.stop 
+      }
+
+      # rails reload
+      trap("HUP") { 
+        server.stop 
+        @restart = true
+      }
+
+      # restart
+      trap("USR2") { 
+        server.stop
+        @restart = true
+      }
+    end
     
     begin
-      puts "Server ready."
+      STDERR.puts "Server ready."
       server.acceptor.join
     rescue Interrupt
-      puts "Interrupted."
+      STDERR.puts "Interrupted."
       raise
     end
+    
+    # daemonize makes restart easy
+    run if @restart
   end
 
   def run
+    Mongrel::PluginManager.instance.load(@load_from) if @load_from
     daemonize
     rails = configure_rails
     start_mongrel(rails)
@@ -140,12 +131,26 @@ class StartCommand < Mongrel::Command::Command
 end
 
 
+def send_signal(signal, pid_file)
+  pid = open(pid_file).read.to_i
+  print "Sending #{signal} to Mongrel at PID #{pid}..."
+  begin
+    Process.kill(signal, pid)
+  rescue Errno::ESRCH
+    puts "Process does not exist.  Not running."
+  end
+  
+  puts "Done."
+end
+
 
-class StopCommand < Mongrel::Command::Command
+class Stop < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
 
   def configure 
-    options [
+    options [ 
              ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, Dir.pwd],
+             ['-f', '--force', "Force the shutdown.", :@force, false],
              ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "log/mongrel.pid"]
     ]
   end
@@ -162,16 +167,48 @@ class StopCommand < Mongrel::Command::Command
 
   
   def run
-    pid = open(@pid_file).read.to_i
-    print "Stopping Mongrel at PID #{pid}..."
-    begin
-      Process.kill("INT", pid)
-    rescue Errno::ESRCH
-      puts "Process does not exist.  Not running."
+    if @force
+      send_signal("KILL", @pid_file)
+    else
+      send_signal("TERM", @pid_file)
+    end
+
+    File.unlink(@pid_file)
+  end
+end
+
+
+
+class Restart < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
+
+  def configure 
+    options [ 
+             ['-c', '--chdir PATH', "Change to dir before starting (will be expanded)", :@cwd, Dir.pwd],
+             ['-s', '--soft', "Do a soft restart rather than a process exit restart", :@soft, false],
+             ['-P', '--pid FILE', "Where to write the PID", :@pid_file, "log/mongrel.pid"]
+    ]
+  end
+  
+  def validate
+    @cwd = File.expand_path(@cwd)
+    valid_dir? @cwd, "Invalid path to change to during daemon mode: #@cwd"
+
+    @pid_file = File.join(@cwd,@pid_file)
+    valid_exists? @pid_file, "PID file #@pid_file does not exist. Not running?" 
+
+    return @valid
+  end
+
+
+  def run
+    if @soft
+      send_signal("HUP", @pid_file)
+    else
+      send_signal("USR2", @pid_file)
     end
 
     File.unlink(@pid_file)
-    puts "Done."
   end
 end
 

data/bin/mongrel_rails_service

@@ -7,8 +7,6 @@
 ###############################################
 require 'rubygems'
 require 'mongrel'
-require 'mongrel/command'
-
 require 'win32/service'
 include Win32
 
@@ -32,7 +30,8 @@ module GenericCommand
   end
 end
 
-class InstallCommand < Mongrel::Command::Command
+class Install < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
 
   # Default every option to nil so only the defined ones get passed to service
   # (which will override ServiceCommand defaults).
@@ -41,12 +40,13 @@ class InstallCommand < Mongrel::Command::Command
       ['-n', '--name SVC_NAME', "Required name for the service to be registered/installed.", :@svc_name, nil],
       ['-d', '--display SVC_DISPLAY', "Adjust the display name of the service.", :@svc_display, nil],
       ['-r', '--root PATH', "Set the root path where your rails app resides.", :@rails_root, Dir.pwd],
-      ['-e', '--environment ENV', "Rails environment to run as", :@environment, 'production'],
+      ['-e', '--environment ENV', "Rails environment to run as. (default: production)", :@environment, 'production'],
       ['-b', '--binding ADDR', "Address to bind to", :@ip, nil],
       ['-p', '--port PORT', "Which port to bind to", :@port, 3000],
       ['-m', '--mime PATH', "A YAML file that lists additional MIME types", :@mime_map, nil],
       ['-P', '--num-procs INT', "Number of processor threads to use", :@num_procs, nil],
       ['-t', '--timeout SECONDS', "Timeout all requests after SECONDS time", :@timeout, nil],
+      ['-c', '--cpu CPU', "Bind the process to specific cpu, starting from 1.", :@cpu, nil]
     ]
   end
 
@@ -70,6 +70,9 @@ class InstallCommand < Mongrel::Command::Command
     valid? app_exist == true, "The root of rails app isn't valid, please verify."
     valid_exists? @mime_map, "MIME mapping file does not exist: #@mime_map" if @mime_map
     
+    # Validate the number of cpu to bind to.
+    valid? @cpu.to_i > 0, "You must specify a numeric value for cpu. (1..8)" if @cpu
+    
     # We should validate service existance here, right Zed?
     begin
       valid? !Service.exists?(@svc_name), "The service already exist, please uninstall it first."
@@ -112,6 +115,9 @@ class InstallCommand < Mongrel::Command::Command
 
     # timeout
     @params << "-t #{@timeout.to_i} " if @timeout
+    
+    # cpu
+    @params << "-c #{@cpu.to_i} " if @cpu
   end
   
   def install_service
@@ -168,7 +174,8 @@ class InstallCommand < Mongrel::Command::Command
   end
 end
 
-class DeleteCommand < Mongrel::Command::Command
+class Delete < Mongrel::Plugin "/commands" 
+  include Mongrel::Command::Base
   include GenericCommand
 
   def run
@@ -186,7 +193,8 @@ class DeleteCommand < Mongrel::Command::Command
   end
 end
 
-class StartCommand < Mongrel::Command::Command
+class Start < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
   include GenericCommand
   
   def run
@@ -210,7 +218,8 @@ class StartCommand < Mongrel::Command::Command
   end
 end
 
-class StopCommand < Mongrel::Command::Command
+class Stop < Mongrel::Plugin "/commands"
+  include Mongrel::Command::Base
   include GenericCommand
   
   def run

data/bin/mongrel_rails_svc

@@ -4,75 +4,57 @@
 # This is where Win32::Daemon resides.
 ###############################################
 require 'rubygems'
-require 'mongrel'
-
+require 'mongrel/rails'
 require 'optparse'
-
 require 'win32/service'
 
-DEBUG_LOG_FILE = File.expand_path(File.dirname(__FILE__) + '/debug.log') 
-#STDERR.reopen(DEBUG_LOG_FILE)
-
-# There are need for SimpleHandler
-require 'yaml'
-require 'zlib'
-
-class RailsHandler < Mongrel::HttpHandler
-
-  def initialize(dir, mime_map = {})
-    @files = Mongrel::DirHandler.new(dir,false)
-    @guard = Mutex.new
-    
-    # register the requested mime types
-    mime_map.each {|k,v| Mongrel::DirHandler::add_mime_type(k,v) }
+# We need to use OpenProcess and SetProcessAffinityMask on WinNT/2K/XP for
+# binding the process to each cpu.
+# Kernel32 Module Just for Win32 :D
+require 'dl/win32'
+
+module Kernel32
+  [
+    %w/OpenProcess            LLL    L/,
+    %w/SetProcessAffinityMask LL     L/,
+  ].each do |fn|
+    const_set fn[0].intern, Win32API.new('kernel32.dll', *fn)
   end
   
-  def process(request, response)
-    # not static, need to talk to rails
-    return if response.socket.closed?
-
-    if @files.can_serve(request.params["PATH_INFO"])
-      @files.process(request,response)
-    else
-      cgi = Mongrel::CGIWrapper.new(request, response)
-
-      begin
-        @guard.synchronize do
-          # Rails is not thread safe so must be run entirely within synchronize 
-          Dispatcher.dispatch(cgi, ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, response.body)
-        end
-
-        # This finalizes the output using the proper HttpResponse way
-        cgi.out {""}
-      rescue Object => rails_error
-        STDERR.puts "calling Dispatcher.dispatch #{rails_error}"
-        STDERR.puts rails_error.backtrace.join("\n")
-      end
-    end
-  end
+  PROCESS_ALL_ACCESS = 0x1f0fff
+  
+  module_function
 
+  def set_affinity(pid, cpu)
+    handle = OpenProcess.call(PROCESS_ALL_ACCESS, 0, pid)
+  
+    # CPU mask is a bit weird, hehehe :)
+    # default mask for CPU 1
+    mask = 1
+    mask = %w{1 2 4 8 16 32 64 128}[cpu.to_i - 1] if cpu.to_i.between?(1, 8)
+    
+    SetProcessAffinityMask.call(handle, mask.to_i)
+  end
 end
+# End Kernel32 Module
 
-class SimpleHandler < Mongrel::HttpHandler
-    def process(request, response)
-      response.start do |head,out|
-        head["Content-Type"] = "text/html"
-        results = "<html><body>Your request:<br /><pre>#{request.params.to_yaml}</pre><a href=\"/files\">View the files.</a></body></html>"
-        if request.params["HTTP_ACCEPT_ENCODING"] == "gzip,deflate"
-          head["Content-Encoding"] = "deflate"
-          # send it back deflated
-          out << Zlib::Deflate.deflate(results)
-        else
-          # no gzip supported, send it back normal
-          out << results
-        end
-      end
-    end
+DEBUG_LOG_FILE = File.expand_path(File.dirname(__FILE__) + '/debug.log') 
+DEBUG_THREAD_LOG_FILE = File.expand_path(File.dirname(__FILE__) + '/debug_thread.log') 
+
+def dbg(msg)
+  File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - #{msg}") }
+end
+  
+def dbg_th(msg)
+  File.open(DEBUG_THREAD_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - #{msg}") }  
 end
 
-class RailsDaemon < Win32::Daemon
+# This class encapsulate the handler registering, http_server and working thread
+# Is standalone, so using MongrelRails in your app get everything runnig 
+# (in case you don't want use mongrel_rails script)
+class MongrelRails
   def initialize(ip, port, rails_root, docroot, environment, mime_map, num_procs, timeout)
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - daemon_initialize entered") }
+    dbg "mongrelrails_initialize entered"
 
     @ip = ip
     @port = port
@@ -83,11 +65,23 @@ class RailsDaemon < Win32::Daemon
     @num_procs = num_procs
     @timeout = timeout
 
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - daemon_initialize left") }
+    dbg "mongrelrails_initialize left"
   end
+  
+  def delayed_initialize
+    dbg "delayed_initialize entered"
+
+    @rails = configure_rails
+    
+    # start up mongrel with the right configurations
+    @server = Mongrel::HttpServer.new(@ip, @port, @num_procs.to_i, @timeout.to_i)
+    @server.register("/", @rails)
 
+    dbg "delayed_initialize left"
+  end
+  
   def load_mime_map
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - load_mime_map entered") }
+    dbg "load_mime_map entered"
 
     mime = {}
 
@@ -100,13 +94,13 @@ class RailsDaemon < Win32::Daemon
       mime.each {|k,v| puts "WARNING: MIME type #{k} must start with '.'" if k.index(".") != 0 }
     end
 
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - load_mime_map left") }
+    dbg "load_mime_map left"
     
     return mime
   end
 
   def configure_rails
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - configure_rails entered") }
+    dbg "configure_rails entered"
 
     Dir.chdir(@rails_root)
 
@@ -116,45 +110,85 @@ class RailsDaemon < Win32::Daemon
     # configure the rails handler
     rails = RailsHandler.new(@docroot, load_mime_map)
     
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - configure_rails left") }
+    dbg "configure_rails left"
 
     return rails
   end
 
-  def service_init
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_init entered") }
+  def start_serve
+    dbg "start_serve entered"
     
-    @rails = configure_rails
-    #@rails = SimpleHandler.new
+    @runner = Thread.new do 
+      dbg_th "runner_thread suspended"
+      Thread.stop
+      
+      dbg_th "runner_thread resumed"
+      dbg_th "runner_thread acceptor.join"
+      @server.acceptor.join
+    end
+
+    dbg "server.run"
+    @server.run
+
+    dbg "runner.run"
+    @runner.run
     
-    # start up mongrel with the right configurations
-    @server = Mongrel::HttpServer.new(@ip, @port, @num_procs.to_i, @timeout.to_i)
-    @server.register("/", @rails)
+    dbg "start_serve left"    
+  end
+  
+  def stop_serve
+    dbg "stop_serve entered"
+
+    if @runner.alive?
+      dbg "killing thread"
+      @runner.kill
+    end
     
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_init left") }    
+    @server.stop
+
+    dbg "stop_serve left"
+  end
+end
+
+class RailsDaemon < Win32::Daemon
+  def initialize(rails)
+    dbg "daemon_initialize entered"
+
+    @rails = rails
+
+    dbg "daemon_initialize left"
+  end
+
+  def service_init
+    dbg "service_init entered"
+    
+    @rails.delayed_initialize
+    
+    dbg "service_init left"    
   end
   
   def service_main
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_main entered") }
+    dbg "service_main entered"
 
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - server.run") }
-    @server.run
+    dbg "rails.start_serve"
+    @rails.start_serve
     
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - while RUNNING") }
+    dbg "while RUNNING"
     while state == RUNNING
       sleep 1
     end
+    dbg "state !RUNNING"
 
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_main left") }
+    dbg "rails.stop_serve"
+    @rails.stop_serve
+    
+    dbg "service_main left"
   end
 
   def service_stop
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_stop entered") }
-
-    #File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - server.stop") }
-    #@server.stop
-
-    File.open(DEBUG_LOG_FILE,"a+") { |f| f.puts("#{Time.now} - service_stop left") }
+    dbg "service_stop entered"
+    
+    dbg "service_stop left"
   end
 end
 
@@ -170,25 +204,88 @@ if ARGV[0] == 'service'
     :port         => 3000,
     :mime_map     => nil,
     :num_procs    => 20,
-    :timeout      => 120
+    :timeout      => 120,
+    :cpu          => nil
   }
   
   ARGV.options do |opts|
     opts.on('-r', '--root PATH', "Set the root path where your rails app resides.") { |OPTIONS[:rails_root]| }
-    opts.on('-e', '--environment ENV', "Rails environment to run as.") { |OPTIONS[:environment]| }
+    opts.on('-e', '--environment ENV', "Rails environment to run as. (default: production)") { |OPTIONS[:environment]| }
     opts.on('-b', '--binding ADDR', "Address to bind to") { |OPTIONS[:ip]| }
     opts.on('-p', '--port PORT', "Which port to bind to") { |OPTIONS[:port]| }
     opts.on('-m', '--mime PATH', "A YAML file that lists additional MIME types") { |OPTIONS[:mime_map]| }
     opts.on('-P', '--num-procs INT', "Number of processor threads to use") { |OPTIONS[:num_procs]| }
     opts.on('-t', '--timeout SECONDS', "Timeout all requests after SECONDS time") { |OPTIONS[:timeout]| }
-    
+    opts.on('-c', '--cpu CPU', "Bind the process to specific cpu") { |OPTIONS[:cpu]| }
+
     opts.parse!
   end
 
+  #expand RAILS_ROOT
+  OPTIONS[:rails_root] = File.expand_path(OPTIONS[:rails_root])
+  
   OPTIONS[:docroot] = File.expand_path(OPTIONS[:rails_root] + '/public')
 
-  rails_svc = RailsDaemon.new(OPTIONS[:ip], OPTIONS[:port], OPTIONS[:rails_root], OPTIONS[:docroot], OPTIONS[:environment], OPTIONS[:mime_map], OPTIONS[:num_procs].to_i, OPTIONS[:timeout].to_i)
+  # We must bind to a specific cpu?
+  if OPTIONS[:cpu]
+    Kernel32.set_affinity(Process.pid, OPTIONS[:cpu])
+  end
+  
+  rails = MongrelRails.new(OPTIONS[:ip], OPTIONS[:port], OPTIONS[:rails_root], OPTIONS[:docroot], OPTIONS[:environment], OPTIONS[:mime_map], OPTIONS[:num_procs].to_i, OPTIONS[:timeout].to_i)
+  rails_svc = RailsDaemon.new(rails)
   rails_svc.mainloop
 
-end
+elsif ARGV[0] == 'debug'
+  ARGV.shift
 
+  # default options
+  OPTIONS = {
+    :rails_root   => Dir.pwd,
+    :environment  => 'production',
+    :ip           => '0.0.0.0',
+    :port         => 3000,
+    :mime_map     => nil,
+    :num_procs    => 20,
+    :timeout      => 120,
+    :cpu          => nil
+  }
+  
+  ARGV.options do |opts|
+    opts.on('-r', '--root PATH', "Set the root path where your rails app resides.") { |OPTIONS[:rails_root]| }
+    opts.on('-e', '--environment ENV', "Rails environment to run as.") { |OPTIONS[:environment]| }
+    opts.on('-b', '--binding ADDR', "Address to bind to") { |OPTIONS[:ip]| }
+    opts.on('-p', '--port PORT', "Which port to bind to") { |OPTIONS[:port]| }
+    opts.on('-m', '--mime PATH', "A YAML file that lists additional MIME types") { |OPTIONS[:mime_map]| }
+    opts.on('-P', '--num-procs INT', "Number of processor threads to use") { |OPTIONS[:num_procs]| }
+    opts.on('-t', '--timeout SECONDS', "Timeout all requests after SECONDS time") { |OPTIONS[:timeout]| }
+    opts.on('-c', '--cpu CPU', "Bind the process to specific cpu") { |OPTIONS[:cpu]| }
+
+    opts.parse!
+  end
+
+  #expand RAILS_ROOT
+  OPTIONS[:rails_root] = File.expand_path(OPTIONS[:rails_root])
+  
+  OPTIONS[:docroot] = File.expand_path(OPTIONS[:rails_root] + '/public')
+
+  # We must bind to a specific cpu?
+  if OPTIONS[:cpu]
+    Kernel32.set_affinity(Process.pid, OPTIONS[:cpu])
+  end
+
+  rails = MongrelRails.new(OPTIONS[:ip], OPTIONS[:port], OPTIONS[:rails_root], OPTIONS[:docroot], OPTIONS[:environment], OPTIONS[:mime_map], OPTIONS[:num_procs].to_i, OPTIONS[:timeout].to_i)
+  rails.delayed_initialize
+  rails.start_serve
+  
+  begin
+    sleep
+  rescue Interrupt
+    puts "graceful shutdown?"
+  end
+
+  begin
+    rails.stop_serve
+  rescue
+  end
+  
+end