mongrel 0.3.11 → 0.3.12

data/Rakefile

@@ -32,7 +32,7 @@ end
 setup_extension("http11", "http11")
 
 name="mongrel"
-version="0.3.11"
+version="0.3.12"
 
 setup_gem(name, version) do |spec|
   spec.summary = "A small fast HTTP library and server that runs Rails, Camping, and Nitro apps."
@@ -65,7 +65,7 @@ task :package_win32 do
     spec.required_ruby_version = '>= 1.8.4'
 
     spec.add_dependency('win32-service', '>= 0.5.0')
-    spec.add_dependency('gem_plugin', ">= 0.2")
+    spec.add_dependency('gem_plugin', ">= 0.2.1")
 
     spec.extensions = []
     spec.platform = Gem::Platform::WIN32
@@ -79,11 +79,13 @@ task :install do
   sh %{sudo gem install pkg/mongrel-#{version}}
   sub_project("mongrel_status", :install)
   sub_project("mongrel_config", :install)
+  sub_project("mongrel_console", :install)
 end
 
 task :uninstall => [:clean] do
   sub_project("mongrel_status", :uninstall)
   sub_project("mongrel_config", :uninstall)
+  sub_project("mongrel_console", :uninstall)
   sh %{sudo gem uninstall mongrel}
   sub_project("gem_plugin", :uninstall)
 end

data/bin/mongrel_rails

@@ -1,6 +1,8 @@
+
 require 'rubygems'
 require 'yaml'
-require 'mongrel'
+require 'mongrel/rails'
+
 
 
 class Start < GemPlugin::Plugin "/commands"
@@ -14,11 +16,13 @@ class Start < GemPlugin::Plugin "/commands"
       ['-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],
+      ['-n', '--num-procs INT', "Number of processor threads to use", :@num_procs, 1024],
+      ['-t', '--timeout SECONDS', "Timeout all requests after SECONDS time", :@timeout, 0],
       ['-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"],
+      ['-B', '--debug', "Enable debugging mode", :@debug, false],
+      ['-C', '--config PATH', "Use a config file", :@config_file, nil]
     ]
   end
   
@@ -33,119 +37,72 @@ class Start < GemPlugin::Plugin "/commands"
     valid_dir? File.dirname(@pid_file), "Path to pid file not valid: #@pid_file"
     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_exists? @config_file, "Config file not there: #@config_file" if @config_file
     return @valid
   end
 
+  def run
 
-  def daemonize 
-    # save this for later since daemonize will hose it
-    if @daemon and RUBY_PLATFORM !~ /mswin/
-      require 'daemons/daemonize'
-
-      puts "Started Mongrel server in #@environment mode at #@address:#@port"
-      Daemonize.daemonize(log_file=File.join(@cwd, @log_file))
-
-      # change back to the original starting directory
-      Dir.chdir(@cwd)
-
-      open(@pid_file,"w") {|f| f.write(Process.pid) }
-    else
-      puts "Running Mongrel server in #@environment mode at #@address:#@port"
-    end
-  end   
-
-  def load_mime_map
-    mime = {}
-
-    # configure any requested mime map
-    if @mime_map
-      puts "Loading additional MIME types from #@mime_map"
-      mime.merge!(YAML.load_file(@mime_map))
-
-      # check all the mime types to make sure they are the right format
-      mime.each {|k,v| puts "WARNING: MIME type #{k} must start with '.'" if k.index(".") != 0 }
+    # command line setting override config file settings
+    settings = { :host => @address,  :port => @port, :cwd => @cwd,
+      :log_file => @log_file, :pid_file => @pid_file, :environment => @environment,
+      :docroot => @docroot, :mime_map => @mime_map, :daemon => @daemon,
+      :debug => @debug, :includes => ["mongrel"]
+    }
+
+    if @config_file
+      STDERR.puts "** Loading settings from #{@config_file} (command line options override)."
+      conf = YAML.load_file(@config_file)
+      settings = conf.merge(settings)
     end
     
-    return mime
-  end
-
-  def configure_rails
-    # need this later for safe reloading
-    $orig_dollar_quote = $".clone
-
-    ENV['RAILS_ENV'] = @environment
-    require 'config/environment'
-    require 'dispatcher'
-    require 'mongrel/rails'
-
-    # configure the rails handler
-    rails = RailsHandler.new(@docroot, load_mime_map)
-    
-    return rails
-  end
-
-  def start_mongrel(rails)
-    @restart = false
-
-    server = Mongrel::HttpServer.new(@address, @port, @num_procs.to_i, @timeout.to_i)
-    server.register("/", rails)
-
-    # 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 
-        File.unlink @pid_file if File.exist?(@pid_file)
-      }
-
-      # rails reload
-      trap("HUP") { 
-        STDERR.puts "Reloading rails..."
-        rails.reload!
-        STDERR.puts "Done reloading rails."
-      }
-
-      # restart
-      trap("USR2") { 
-        server.stop
-        File.unlink @pid_file if File.exist?(@pid_file)
-        @restart = true
-      }
+    config = Mongrel::Rails::RailsConfigurator.new(settings) do
+      log "Starting Mongrel in #{settings[:environment]} mode at #{settings[:host]}:#{settings[:port]}"
+      
+      if defaults[:daemon]
+        log "Daemonizing, any open files are closed.  Look at #{settings[:pid_file]} and #{settings[:log_file]} for info."
+        daemonize
+      end
+      
+      listener do
+        mime = {}
+        if defaults[:mime_map]
+          log "Loading additional MIME types from #{settings[:mime_map]}"
+          mime = load_mime_map(defaults[:mime_map], mime)
+        end
+        
+        if defaults[:debug]
+          log "Installing debugging prefixed filters.  Look in log/mongrel_debug for the files."
+          debug "/"
+        end
+
+        log "Starting Rails in environment #{settings[:environment]} ..."
+        uri "/", :handler => rails
+        log "Rails loaded."
+
+        log "Loading any Rails specific GemPlugins"
+        load_plugins
+
+        setup_rails_signals
+      end
     end
 
-    # hook up any rails specific plugins
-    GemPlugin::Manager.instance.load "mongrel" => GemPlugin::INCLUDE
-
-    begin
-      # start mongrel processing thread
-      server.run
+    config.run
+    config.log "Mongrel available at #{settings[:host]}:#{settings[:port]}"
+    config.join
 
+    if config.needs_restart
       if RUBY_PLATFORM !~ /mswin/
-        puts "Server Ready.  Use CTRL-C to quit."
+        cmd = "ruby #{__FILE__} start #{original_args.join(' ')}"
+        config.log "Restarting with arguments:  #{cmd}"
+        exec cmd
       else
-        puts "Server Ready.  Use CTRL-Pause/Break to quit."
+        config.log "Win32 does not support restarts. Exiting."
       end
-
-      server.acceptor.join
-    rescue Interrupt
-      STDERR.puts "Interrupted."
-      raise
     end
-    
-    # daemonize makes restart easy
-    run if @restart
-  end
-
-  def run
-    daemonize
-    rails = configure_rails
-    start_mongrel(rails)
   end
 end
 
-
 def send_signal(signal, pid_file)
   pid = open(pid_file).read.to_i
   print "Sending #{signal} to Mongrel at PID #{pid}..."
@@ -223,6 +180,13 @@ class Restart < GemPlugin::Plugin "/commands"
   end
 end
 
+
 GemPlugin::Manager.instance.load "mongrel" => GemPlugin::INCLUDE, "rails" => GemPlugin::EXCLUDE
 
-Mongrel::Command::Registry.instance.run ARGV
+
+if not Mongrel::Command::Registry.instance.run ARGV
+   exit 1
+end
+
+
+

data/bin/mongrel_rails_service

@@ -80,7 +80,7 @@ class Install < GemPlugin::Plugin "/commands"
     end
     
     # Expand to get full path for mime-types file
-    @mime_map = File.Expand_path(@mime_map) if @mime_map
+    @mime_map = File.expand_path(@mime_map) if @mime_map
     
     # default service display to service name
     @svc_display = @svc_name if !@svc_display

data/bin/mongrel_rails_svc

@@ -4,6 +4,7 @@
 # This is where Win32::Daemon resides.
 ###############################################
 require 'rubygems'
+require 'mongrel'
 require 'mongrel/rails'
 require 'optparse'
 require 'win32/service'
@@ -70,14 +71,15 @@ class MongrelRails
   
   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
@@ -104,11 +106,12 @@ class MongrelRails
 
     Dir.chdir(@rails_root)
 
+    
     ENV['RAILS_ENV'] = @environment
-    require File.join(@rails_root, 'config/environment')
+    require 'config/environment'
 
     # configure the rails handler
-    rails = RailsHandler.new(@docroot, load_mime_map)
+    rails = Mongrel::Rails::RailsHandler.new(@docroot, load_mime_map)
     
     dbg "configure_rails left"
 
@@ -116,24 +119,29 @@ class MongrelRails
   end
 
   def start_serve
-    dbg "start_serve entered"
-    
-    @runner = Thread.new do 
-      dbg_th "runner_thread suspended"
-      Thread.stop
+    begin
+      dbg "start_serve entered"
+      
+      @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_th "runner_thread resumed"
-      dbg_th "runner_thread acceptor.join"
-      @server.acceptor.join
+      dbg "server.run"
+      @server.run
+      
+      dbg "runner.run"
+      @runner.run
+      
+      dbg "start_serve left"    
+    rescue
+      dbg "ERROR: #$!\r\n"
+      dbg $!.backtrace.join("\r\n")
     end
-
-    dbg "server.run"
-    @server.run
-
-    dbg "runner.run"
-    @runner.run
-    
-    dbg "start_serve left"    
   end
   
   def stop_serve
@@ -193,99 +201,107 @@ class RailsDaemon < Win32::Daemon
 end
 
 
-if ARGV[0] == 'service'
-  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. (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')
-
-  # 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
-
-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
-  
+begin
+  if ARGV[0] == 'service'
+    ARGV.shift
+    
+    # default options
+    OPTIONS = {
+      :rails_root   => Dir.pwd,
+      :environment  => 'production',
+      :ip           => '0.0.0.0',
+      :port         => 3000,
+      :mime_map     => nil,
+      :num_procs    => 1024,
+      :timeout      => 0,
+      :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. (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')
+    
+    # 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
+    
+  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
+      dbg "ERROR: #$!\r\n"
+      dbg $!.backtrace.join("\r\n")
+      puts "graceful shutdown?"
+    end
+    
+    begin
+      rails.stop_serve
+    rescue
+      dbg "ERROR: #$!\r\n"
+      dbg $!.backtrace.join("\r\n")
+    end
+  end  
+rescue
+  dbg "ERROR: #$!\r\n"
+  dbg $!.backtrace.join("\r\n")  
 end