0
@@ -36,6 +36,7 @@ module Merb
0
   module GlobalHelpers; end
0
   
0
   class << self
0
+    attr_accessor :exiting
0
 
0
     # Merge environment settings
0
     # Can allow you to have a "localdev" that runs like your "development"
0
@@ -93,18 +94,24 @@ module Merb
0
     # argv<String, Hash>::
0
     #   The config arguments to start Merb with. Defaults to +ARGV+.
0
     def start(argv=ARGV)
0
+      # Hardcode the log stream to STDOUT
0
+      Merb::Config[:log_stream] = STDOUT
0
       if Hash === argv
0
         Merb::Config.setup(argv)
0
       else
0
         Merb::Config.parse_args(argv)
0
       end
0
+      Merb::Config[:log_stream] = STDOUT
0
+      
0
       Merb.environment = Merb::Config[:environment]
0
       Merb.root = Merb::Config[:merb_root]
0
       case Merb::Config[:action]
0
       when :kill
0
-        Merb::Server.kill(Merb::Config[:port], 1)
0
+        Merb::Server.kill(Merb::Config[:port], 2)
0
       when :kill_9
0
         Merb::Server.kill(Merb::Config[:port], 9)
0
+      when :fast_deploy
0
+        Merb::Server.kill("main", "HUP")
0
       else
0
         Merb::Server.start(Merb::Config[:port], Merb::Config[:cluster])
0
       end
0
@@ -263,21 +270,43 @@ module Merb
0
     end
0
 
0
     # Logger settings
0
-    attr_accessor :logger
0
+    def logger
0
+      Thread.current[:merb_logger] ||= Merb::Logger.new
0
+    end
0
+
0
+    def logger=(obj)
0
+      unless obj
0
+        Thread.current[:merb_logger] = nil
0
+      end
0
+    end
0
 
0
     # ==== Returns
0
     # String::
0
     #   The path to the log file. If this Merb instance is running as a daemon
0
     #   this will return +STDOUT+.
0
-    def log_file
0
-      if Merb::Config[:log_file]
0
-        Merb::Config[:log_file]
0
-      elsif Merb.testing?
0
-        log_path / "merb_test.log"
0
-      elsif !(Merb::Config[:daemonize] || Merb::Config[:cluster])
0
-        STDOUT
0
-      else
0
-        log_path / "merb.#{Merb::Config[:port]}.log"
0
+    def log_stream(port = "main")
0
+      @streams ||= {}
0
+      @streams[port] ||= begin
0
+        log = if Merb.testing?
0
+          log_path / "merb_test.log"
0
+        elsif !Merb::Config[:daemonize]
0
+          STDOUT
0
+        else
0
+          log_path / "merb.#{port}.log"
0
+        end        
0
+        
0
+        if log.is_a?(IO)
0
+          stream = log
0
+        elsif File.exist?(log)
0
+          stream = File.open(log, (File::WRONLY | File::APPEND))
0
+        else
0
+          FileUtils.mkdir_p(File.dirname(log))
0
+          stream = File.open(log, (File::WRONLY | File::APPEND | File::CREAT))
0
+          stream.write("#{Time.now.httpdate} #{Merb::Config[:log_delimiter]} " \
0
+            "info #{Merb::Config[:log_delimiter]} Logfile created\n")
0
+        end
0
+        stream.sync = true
0
+        stream
0
       end
0
     end
0
 
0
@@ -335,6 +364,28 @@ module Merb
0
         r.default_routes
0
       end
0
     end
0
+    
0
+    def fatal!(str, e = nil)
0
+      Merb.logger.fatal!
0
+      Merb.logger.fatal!("\e[1;31;47mFATAL: #{str}\e[0m")
0
+      Merb.logger.fatal!
0
+
0
+      print_colorized_backtrace(e) if e && Merb::Config[:verbose]
0
+      exit(1)
0
+    end
0
+    
0
+    def print_colorized_backtrace(e)
0
+      e.backtrace.map! do |line|
0
+        line.gsub!(/^#{Merb.framework_root}/, "\e[34mFRAMEWORK_ROOT\e[31m")
0
+      end
0
+      
0
+      Merb.logger.fatal! "\e[34mFRAMEWORK_ROOT\e[0m = #{Merb.framework_root}"
0
+      Merb.logger.fatal!
0
+      Merb.logger.fatal! "\e[31m#{e.class}: \e[1;31;47m#{e.message}\e[0m"
0
+      e.backtrace.each do |line|
0
+        Merb.logger.fatal! "\e[31m#{line}\e[0m"
0
+      end      
0
+    end
0
 
0
     # Set up default variables under Merb
0
     attr_accessor :klass_hashes, :orm, :test_framework, :template_engine

0
@@ -6,7 +6,8 @@ module Merb
0
     #---
0
     # @semipublic
0
     cattr_accessor :subclasses, :after_load_callbacks, :before_load_callbacks, :finished
0
-    self.subclasses, self.after_load_callbacks, self.before_load_callbacks, self.finished = [], [], [], []
0
+    self.subclasses, self.after_load_callbacks, 
0
+      self.before_load_callbacks, self.finished = [], [], [], []
0
 
0
     class << self
0
 
0
@@ -144,13 +145,23 @@ class Merb::BootLoader::Logger < Merb::BootLoader
0
 
0
   # Sets Merb.logger to a new logger created based on the config settings.
0
   def self.run
0
-    Merb.logger = Merb::Logger.new(Merb.log_file, Merb::Config[:log_level], Merb::Config[:log_delimiter], Merb::Config[:log_auto_flush])
0
+    Merb::Config[:log_level] ||= begin
0
+      if Merb.environment == "production"
0
+        Merb::Logger::Levels[:warn]
0
+      else
0
+        Merb::Logger::Levels[:debug]
0
+      end          
0
+    end
0
+    
0
+    Merb::Config[:log_stream] = Merb.log_stream
0
+    
0
     print_warnings
0
   end
0
   
0
   def self.print_warnings
0
     if Gem::Version.new(Gem::RubyGemsVersion) < Gem::Version.new("1.1")
0
-      Merb.logger.warn! "Merb requires Rubygems 1.1 and later. Please upgrade RubyGems with gem update --system."
0
+      Merb.fatal! "Merb requires Rubygems 1.1 and later. " \
0
+        "Please upgrade RubyGems with gem update --system."
0
     end
0
   end
0
 end
0
@@ -164,7 +175,7 @@ class Merb::BootLoader::DropPidFile <  Merb::BootLoader
0
 
0
     # Stores a PID file if Merb is running daemonized or clustered.
0
     def run
0
-      Merb::Server.store_pid(Merb::Config[:port]) if Merb::Config[:daemonize] || Merb::Config[:cluster]
0
+      Merb::Server.store_pid("main") #if Merb::Config[:daemonize] || Merb::Config[:cluster]
0
     end
0
   end
0
 end
0
@@ -269,14 +280,17 @@ class Merb::BootLoader::Dependencies < Merb::BootLoader
0
   end
0
 
0
   def self.enable_json_gem
0
+    gem "json"
0
     require "json/ext"
0
   rescue LoadError
0
+    gem "json_pure"
0
     require "json/pure"
0
   end
0
 
0
   def self.update_logger
0
-    updated_logger_options = [ Merb.log_file, Merb::Config[:log_level], Merb::Config[:log_delimiter], Merb::Config[:log_auto_flush] ]
0
-    Merb::BootLoader::Logger.run if updated_logger_options != Merb.logger.init_args
0
+    # Clear out the logger so that any changes in init.rb will be
0
+    # picked up
0
+    Merb.logger = nil
0
   end
0
 
0
   private
0
@@ -356,10 +370,24 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
0
     # Load all classes from Merb's native load paths.
0
     def run
0
       # Add models, controllers, helpers and lib to the load path
0
-      $LOAD_PATH.unshift Merb.dir_for(:model)
0
-      $LOAD_PATH.unshift Merb.dir_for(:controller)
0
-      $LOAD_PATH.unshift Merb.dir_for(:lib)
0
-      $LOAD_PATH.unshift Merb.dir_for(:helper)
0
+      unless @ran
0
+        $LOAD_PATH.unshift Merb.dir_for(:model)
0
+        $LOAD_PATH.unshift Merb.dir_for(:controller)
0
+        $LOAD_PATH.unshift Merb.dir_for(:lib)
0
+        $LOAD_PATH.unshift Merb.dir_for(:helper)
0
+      end
0
+
0
+      @ran = true
0
+      $0 = "merb: master"
0
+      
0
+      if Merb::Config[:fork_for_class_load] && Merb.env != "test"
0
+        start_transaction
0
+      else
0
+        trap('INT') do 
0
+          Merb.logger.warn! "Killing children"
0
+          kill_children
0
+        end
0
+      end
0
 
0
       # Load application file if it exists - for flat applications
0
       load_file Merb.dir_for(:application) if File.file?(Merb.dir_for(:application))
0
@@ -373,13 +401,141 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
0
       Merb::Controller.send :include, Merb::GlobalHelpers
0
     end
0
     
0
+    # Wait for any children to exit, remove the "main" PID, and
0
+    # exit.
0
+    def exit_gracefully
0
+      Process.waitall
0
+      Merb::Server.remove_pid("main")
0
+      exit
0
+    end
0
+    
0
+    # If using fork-based code reloading, set up the BEGIN
0
+    # point and set up any signals in the parent and child.
0
+    def start_transaction
0
+      Merb.logger.warn! "Parent pid: #{Process.pid}"
0
+      reader, writer = nil, nil
0
+      
0
+      if GC.respond_to?(:copy_on_write_friendly=)
0
+        GC.copy_on_write_friendly = true
0
+      end      
0
+            
0
+      loop do
0
+        reader, @writer = IO.pipe
0
+        pid = Kernel.fork
0
+        
0
+        # pid means we're in the parent; only stay in the loop in that case
0
+        break unless pid
0
+        @writer.close
0
+
0
+        Merb::Server.store_pid("main")
0
+        
0
+        if Merb::Config[:console_trap]
0
+          trap("INT") {}
0
+        else
0
+          trap("INT") do 
0
+            Merb.logger.warn! "Killing children"
0
+            begin
0
+              Process.kill("ABRT", pid)
0
+            rescue SystemCallError
0
+            end
0
+            exit_gracefully
0
+          end
0
+        end
0
+        
0
+        trap("HUP") do 
0
+          Merb.logger.warn! "Doing a fast deploy\n"
0
+          Process.kill("HUP", pid)
0
+        end
0
+
0
+        reader_ary = [reader]
0
+        loop do
0
+          if exit_status = Process.wait2(pid, Process::WNOHANG)
0
+            exit_status[1] == 128 ? break : exit
0
+          end
0
+          if select(reader_ary, nil, nil, 0.25)
0
+            begin
0
+              next if reader.eof?
0
+              msg = reader.readline
0
+              if msg =~ /128/
0
+                break
0
+              else
0
+                exit_gracefully
0
+              end
0
+            rescue SystemCallError
0
+              exit_gracefully
0
+            end
0
+          end
0
+        end
0
+      end
0
+ 
0
+      reader.close
0
+ 
0
+      # add traps to the child
0
+      if Merb::Config[:console_trap]
0
+        Merb::Server.add_irb_trap
0
+        at_exit { kill_children }
0
+      else
0
+        trap('INT') {}
0
+        trap('ABRT') { kill_children }
0
+        trap('HUP') { kill_children(128) }
0
+      end
0
+    end
0
+    
0
+    # Kill any children of the spawner process and exit with
0
+    # an appropriate status code.
0
+    #
0
+    # Note that exiting the spawner process with a status code
0
+    # of 128 when a master process exists will cause the
0
+    # spawner process to be recreated, and the app code reloaded.
0
+    #
0
+    # @param status<Integer> The status code to exit with
0
+    def kill_children(status = 0)
0
+      Merb.exiting = true unless status == 128
0
+      
0
+      begin
0
+        @writer.puts(status.to_s) if @writer
0
+      rescue SystemCallError
0
+      end
0
+      
0
+      threads = []
0
+      
0
+      ($CHILDREN || []).each do |p|
0
+        threads << Thread.new do
0
+          begin
0
+            Process.kill("ABRT", p)
0
+            Process.wait2(p)
0
+          rescue SystemCallError
0
+          end
0
+        end
0
+      end
0
+      threads.each {|t| t.join }
0
+      exit(status)
0
+    end
0
+    
0
     # ==== Parameters
0
     # file<String>:: The file to load.
0
     def load_file(file)
0
-      klasses = ObjectSpace.classes.dup
0
-      load file
0
-      LOADED_CLASSES[file] = ObjectSpace.classes - klasses
0
-      MTIMES[file] = File.mtime(file)
0
+      # Don't do this expensive operation unless we need to
0
+      unless Merb::Config[:fork_for_class_load]
0
+        klasses = ObjectSpace.classes.dup
0
+      end
0
+      
0
+      # Ignore the file for syntax errors. The next time
0
+      # the file is changed, it'll be reloaded again
0
+      begin
0
+        load file
0
+      rescue SyntaxError
0
+        return
0
+      ensure
0
+        if Merb::Config[:reload_classes]
0
+          MTIMES[file] = File.mtime(file)
0
+        end
0
+      end
0
+      
0
+      # Don't do this expensive operation unless we need to
0
+      unless Merb::Config[:fork_for_class_load]
0
+        LOADED_CLASSES[file] = ObjectSpace.classes - klasses
0
+      end
0
     end
0
     
0
     # Load classes from given paths - using path/glob pattern.
0
@@ -403,7 +559,11 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
0
     # ==== Parameters
0
     # file<String>:: The file to reload.
0
     def reload(file)
0
-      remove_classes_in_file(file) { |f| load_file(f) }
0
+      if !Merb::Config[:fork_for_class_load]
0
+        remove_classes_in_file(file) { |f| load_file(f) }
0
+      else
0
+        kill_children(128)
0
+      end
0
     end
0
     
0
     # Reload the router to regenerate all routes.
0
@@ -489,10 +649,11 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader
0
         if klasses.size == size_at_start && klasses.size != 0
0
           # Write all remaining failed classes and their exceptions to the log
0
           messages = error_map.only(*failed_classes).map do |klass, e|
0
-            ["Could not load #{klass}:\n\n#{e.message} - (#{e.class})", "#{(e.backtrace || []).join("\n")}"]
0
+            ["Could not load #{klass}:\n\n#{e.message} - (#{e.class})", 
0
+              "#{(e.backtrace || []).join("\n")}"]
0
           end
0
           messages.each { |msg, trace| Merb.logger.fatal!("#{msg}\n\n#{trace}") }
0
-          raise LoadError, "#{messages[0][0]} (see log for details)"
0
+          Merb.fatal! "#{failed_classes.join(", ")} failed to load."
0
         end
0
         break if(klasses.size == size_at_start || klasses.size == 0)
0
       end
0
@@ -681,7 +842,7 @@ class Merb::BootLoader::ReloadClasses < Merb::BootLoader
0
       Thread.new do
0
         loop do
0
           sleep( seconds )
0
-          block.call
0
+          yield
0
         end
0
         Thread.exit
0
       end
0
@@ -692,26 +853,33 @@ class Merb::BootLoader::ReloadClasses < Merb::BootLoader
0
   def self.run
0
     return unless Merb::Config[:reload_classes]
0
 
0
-    TimedExecutor.every(Merb::Config[:reload_time] || 0.5) do
0
-      reload
0
-    end
0
-    
0
-  end
0
-
0
-  # Reloads all files.
0
-  def self.reload
0
     paths = []
0
     Merb.load_paths.each do |path_name, file_info|
0
       path, glob = file_info
0
       next unless glob
0
       paths << Dir[path / glob]
0
     end
0
+  
0
+    if Merb.dir_for(:application) && File.file?(Merb.dir_for(:application))
0
+      paths << Merb.dir_for(:application)
0
+    end
0
 
0
-    paths << Merb.dir_for(:application) if Merb.dir_for(:application) && File.file?(Merb.dir_for(:application))
0
+    paths.flatten!
0
 
0
-    paths.flatten.each do |file|
0
-      next if Merb::BootLoader::LoadClasses::MTIMES[file] && Merb::BootLoader::LoadClasses::MTIMES[file] == File.mtime(file)
0
-      Merb::BootLoader::LoadClasses.reload(file)
0
+    TimedExecutor.every(Merb::Config[:reload_time] || 0.5) do
0
+      GC.start
0
+      reload(paths)
0
+    end
0
+    
0
+  end
0
+
0
+  # Reloads all files.
0
+  def self.reload(paths)
0
+    paths.each do |file|
0
+      next if LoadClasses::MTIMES[file] &&  
0
+        LoadClasses::MTIMES[file] == File.mtime(file)
0
+          
0
+      LoadClasses.reload(file)
0
     end
0
   end
0
 end

0
@@ -14,6 +14,7 @@ module Merb
0
           :port                   => "4000",
0
           :adapter                => "runner",
0
           :reload_classes         => true,
0
+          :fork_for_class_load    => !RUBY_PLATFORM.in?("windows", "java"),
0
           :environment            => "development",
0
           :merb_root              => Dir.pwd,
0
           :use_mutex              => true,
0
@@ -102,6 +103,12 @@ module Merb
0
       #   Configuration settings to use. These are merged with the defaults.
0
       def setup(settings = {})
0
         @configuration = defaults.merge(settings)
0
+        
0
+        unless @configuration[:reload_classes]
0
+          @configuration[:fork_for_class_load] = false
0
+        end
0
+        
0
+        @configuration
0
       end
0
 
0
       # Parses the command line arguments and stores them in the config.
0
@@ -122,99 +129,158 @@ module Merb
0
 
0
           opts.banner = "Usage: merb [uGdcIpPhmailLerkKX] [argument]"
0
           opts.define_head "Merb. Pocket rocket web framework"
0
-          opts.separator '*'*80
0
-          opts.separator 'If no flags are given, Merb starts in the foreground on port 4000.'
0
-          opts.separator '*'*80
0
-
0
-          opts.on("-u", "--user USER", "This flag is for having merb run as a user other than the one currently logged in. Note: if you set this you must also provide a --group option for it to take effect.") do |user|
0
+          opts.separator '*' * 80
0
+          opts.separator "If no flags are given, Merb starts in the " \
0
+            "foreground on port 4000."
0
+          opts.separator '*' * 80
0
+
0
+          opts.on("-u", "--user USER", "This flag is for having merb run " \
0
+                  "as a user other than the one currently logged in. Note: " \
0
+                  "if you set this you must also provide a --group option " \
0
+                  "for it to take effect.") do |user|
0
             options[:user] = user
0
           end
0
 
0
-          opts.on("-G", "--group GROUP", "This flag is for having merb run as a group other than the one currently logged in. Note: if you set this you must also provide a --user option for it to take effect.") do |group|
0
+          opts.on("-G", "--group GROUP", "This flag is for having merb run " \
0
+                  "as a group other than the one currently logged in. Note: " \
0
+                  "if you set this you must also provide a --user option " \
0
+                  "for it to take effect.") do |group|
0
             options[:group] = group
0
           end
0
 
0
-          opts.on("-d", "--daemonize", "This will run a single merb in the background.") do |daemon|
0
+          opts.on("-d", "--daemonize", "This will run a single merb in the " \
0
+                  "background.") do |daemon|
0
             options[:daemonize] = true
0
           end
0
+          
0
+          opts.on("-N", "--no-daemonize", "This will allow you to run a " \
0
+                  "cluster in console mode") do |no_daemon|
0
+            options[:daemonize] = false
0
+          end
0
 
0
-          opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run.") do |nodes|
0
+          opts.on("-c", "--cluster-nodes NUM_MERBS", Integer, 
0
+                  "Number of merb daemons to run.") do |nodes|
0
+            options[:daemonize] = true unless options.key?(:daemonize)
0
             options[:cluster] = nodes
0
           end
0
 
0
-          opts.on("-I", "--init-file FILE", "File to use for initialization on load, defaults to config/init.rb") do |init_file|
0
+          opts.on("-I", "--init-file FILE", "File to use for initialization " \
0
+                  "on load, defaults to config/init.rb") do |init_file|
0
             options[:init_file] = init_file
0
           end
0
 
0
-          opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
0
+          opts.on("-p", "--port PORTNUM", Integer, "Port to run merb on, " \
0
+                  "defaults to 4000.") do |port|
0
             options[:port] = port
0
           end
0
 
0
-          opts.on("-o", "--socket-file FILE", "Socket file to run merb on, defaults to [Merb.root]/log/merb.sock") do |port|
0
+          opts.on("-o", "--socket-file FILE", "Socket file to run merb on, " \
0
+                  "defaults to [Merb.root]/log/merb.sock. This is for " \
0
+                  "web servers, like thin, that use sockets.") do |port|
0
             options[:socket_file] = port
0
           end
0
 
0
-          opts.on("-s", "--socket SOCKNUM", "Socket number to run merb on, defaults to 0.") do |port|
0
+          opts.on("-s", "--socket SOCKNUM", Integer, "Socket number to run " \
0
+                  "merb on, defaults to 0.") do |port|
0
             options[:socket] = port
0
           end
0
 
0
-          opts.on("-P", "--pid PIDFILE", "PID file, defaults to [Merb.root]/log/merb.[port_number].pid") do |pid_file|
0
+          opts.on("-P", "--pid PIDFILE", "PID file, defaults to " \
0
+                  "[Merb.root]/log/merb.main.pid for the master process and" \
0
+                  "[Merb.root]/log/merb.[port number].pid for worker " \
0
+                  "processes. For clusters, use %s to specify where " \
0
+                  "in the file merb should place the port number. For " \
0
+                  "instance: -P myapp.%s.pid") do |pid_file|
0
             options[:pid_file] = pid_file
0
           end
0
 
0
-          opts.on("-h", "--host HOSTNAME", "Host to bind to (default is 0.0.0.0).") do |host|
0
+          opts.on("-h", "--host HOSTNAME", "Host to bind to " \
0
+                  "(default is 0.0.0.0).") do |host|
0
             options[:host] = host
0
           end
0
 
0
-          opts.on("-m", "--merb-root /path/to/approot", "The path to the Merb.root for the app you want to run (default is current working dir).") do |root|
0
+          opts.on("-m", "--merb-root /path/to/approot", "The path to the " \
0
+                  "Merb.root for the app you want to run " \
0
+                  "(default is current working directory).") do |root|
0
             options[:merb_root] = File.expand_path(root)
0
           end
0
 
0
-          opts.on("-a", "--adapter mongrel", "The rack adapter to use to run merb[mongrel, emongrel, thin, ebb, fastcgi, webrick, runner, irb]") do |adapter|
0
-            options[:adapter] = adapter
0
+          adapters = [:mongrel, :emongrel, :thin, :ebb, :fastcgi, :webrick]
0
+
0
+          opts.on("-a", "--adapter ADAPTER",
0
+                  "The rack adapter to use to run merb (default is mongrel)" \
0
+                  "[#{adapters.join(', ')}]") do |adapter|
0
+            options[:adapter] ||= adapter
0
           end
0
 
0
-          opts.on("-R", "--rackup FILE", "Load an alternate Rack config file (default is config/rack.rb)") do |rackup|
0
+          opts.on("-R", "--rackup FILE", "Load an alternate Rack config " \
0
+                  "file (default is config/rack.rb)") do |rackup|
0
             options[:rackup] = rackup
0
           end
0
 
0
-          opts.on("-i", "--irb-console", "This flag will start merb in irb console mode. All your models and other classes will be available for you in an irb session.") do |console|
0
+          opts.on("-i", "--irb-console", "This flag will start merb in " \
0
+                  "irb console mode. All your models and other classes will " \
0
+                  "be available for you in an irb session.") do |console|
0
             options[:adapter] = 'irb'
0
           end
0
 
0
-          opts.on("-S", "--sandbox", "This flag will enable a sandboxed irb console. If your ORM supports transactions, all edits will be rolled back on exit.") do |sandbox|
0
+          opts.on("-S", "--sandbox", "This flag will enable a sandboxed irb " \
0
+                  "console. If your ORM supports transactions, all edits will " \
0
+                  "be rolled back on exit.") do |sandbox|
0
             options[:sandbox] = true
0
           end
0
 
0
-          opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of these options: debug < info < warn < error < fatal") do |log_level|
0
+          opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of " \
0
+                  "these options: debug < info < warn < error < " \
0
+                  "fatal (default is info)") do |log_level|
0
             options[:log_level] = log_level.to_sym
0
           end
0
 
0
-          opts.on("-L", "--log LOGFILE", "A string representing the logfile to use.") do |log_file|
0
+          opts.on("-L", "--log LOGFILE", "A string representing the logfile to " \
0
+                  "use. Defaults to [Merb.root]/log/merb.[main].log for the " \
0
+                  "master process and [Merb.root]/log/merb[port number].log" \
0
+                  "for worker processes") do |log_file|
0
             options[:log_file] = log_file
0
           end
0
 
0
-          opts.on("-e", "--environment STRING", "Run merb in the correct mode(development, production, testing)") do |env|
0
+          opts.on("-e", "--environment STRING", "Environment to run Merb " \
0
+                  "under [development, production, testing] " \
0
+                  "(default is development)") do |env|
0
             options[:environment] = env
0
           end
0
 
0
           opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]",
0
-          "Command-line option to run scripts and/or code in the merb app.") do |code_or_file|
0
+                  "Command-line option to run scripts and/or code in the " \
0
+                  "merb app.") do |code_or_file|
0
             options[:runner_code] = code_or_file
0
             options[:adapter] = 'runner'
0
           end
0
 
0
-          opts.on("-K", "--graceful PORT or all", "Gracefully kill one merb proceses by port number.  Use merb -K all to gracefully kill all merbs.") do |ports|
0
+          opts.on("-K", "--graceful PORT or all", "Gracefully kill one " \
0
+                  "merb proceses by port number.  Use merb -K all to " \
0
+                  "gracefully kill all merbs.") do |ports|
0
             options[:action] = :kill
0
+            ports = "main" if ports == "all"
0
             options[:port] = ports
0
           end
0
 
0
-          opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number.  Use merb -k all to kill all merbs.") do |port|
0
+          opts.on("-k", "--kill PORT", "Force kill one merb worker " \
0
+                  "by port number. This will cause the worker to" \
0
+                  "be respawned. If you want to kill ") do |port|
0
             options[:action] = :kill_9
0
+            port = "main" if port == "all"
0
             options[:port] = port
0
           end
0
+          
0
+          opts.on("--fast-deploy", "Reload the code, but not your" \
0
+            "init.rb or gems") do
0
+              options[:action] = :fast_deploy
0
+          end
0
 
0
-          opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
0
+          # @todo Do we really need this flag? It seems unlikely to want to
0
+          #   change the mutex from the command-line.
0
+          opts.on("-X", "--mutex on/off", "This flag is for turning the " \
0
+                  "mutex lock on and off.") do |mutex|
0
             if mutex == "off"
0
               options[:use_mutex] = false
0
             else
0
@@ -226,10 +292,13 @@ module Merb
0
             begin
0
               require "ruby-debug"
0
               Debugger.start
0
-              Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
0
+              if Debugger.respond_to?(:settings)
0
+                Debugger.settings[:autoeval] = true
0
+              end
0
               puts "Debugger enabled"
0
             rescue LoadError
0
-              puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
0
+              puts "You need to install ruby-debug to run the server in " \
0
+                "debugging mode. With gems, use `gem install ruby-debug'"
0
               exit
0
             end
0
           end
0
@@ -249,7 +318,11 @@ module Merb
0
         end
0
 
0
         # Parse what we have on the command line
0
-        opts.parse!(argv)
0
+        begin
0
+          opts.parse!(argv)
0
+        rescue OptionParser::InvalidOption => e
0
+          Merb.fatal! e.message, e
0
+        end
0
         Merb::Config.setup(options)
0
       end
0
 

0
@@ -1,203 +1,215 @@
0
-Merb::Logger = Extlib::Logger
0
+# Merb::Logger = Extlib::Logger
0
+
0
+class Merb::Logger < Extlib::Logger
0
+  def verbose!(message, level = :warn)
0
+    send("#{level}!", message) if Merb::Config[:verbose]
0
+  end
0
+
0
+  def verbose(message, level = :warn)
0
+    send(level, message) if Merb::Config[:verbose]
0
+  end
0
+end
0
+
0
 # require "time" # httpdate
0
-# # ==== Public Merb Logger API
0
-# #
0
-# # To replace an existing logger with a new one:
0
-# #  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
0
-# #
0
-# # Available logging levels are
0
-# #   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
0
-# #
0
-# # Logging via:
0
-# #   Merb.logger.fatal(message<String>,&block)
0
-# #   Merb.logger.error(message<String>,&block)
0
-# #   Merb.logger.warn(message<String>,&block)
0
-# #   Merb.logger.info(message<String>,&block)
0
-# #   Merb.logger.debug(message<String>,&block)
0
-# #
0
-# # Logging with autoflush:
0
-# #   Merb.logger.fatal!(message<String>,&block)
0
-# #   Merb.logger.error!(message<String>,&block)
0
-# #   Merb.logger.warn!(message<String>,&block)
0
-# #   Merb.logger.info!(message<String>,&block)
0
-# #   Merb.logger.debug!(message<String>,&block)
0
-# #
0
-# # Flush the buffer to 
0
-# #   Merb.logger.flush
0
-# #
0
-# # Remove the current log object
0
-# #   Merb.logger.close
0
-# # 
0
-# # ==== Private Merb Logger API
0
-# # 
0
-# # To initialize the logger you create a new object, proxies to set_log.
0
-# #   Merb::Logger.new(log{String, IO},level{Symbol, String})
0
-# module Merb
0
-# 
0
-#   class << self
0
-#     attr_accessor :logger
0
-#   end
0
-# 
0
-#   class Logger
0
-# 
0
-#     attr_accessor :level
0
-#     attr_accessor :delimiter
0
-#     attr_accessor :auto_flush
0
-#     attr_reader   :buffer
0
-#     attr_reader   :log
0
-#     attr_reader   :init_args
0
-# 
0
-#     # ==== Notes
0
-#     # Ruby (standard) logger levels:
0
-#     # :fatal:: An unhandleable error that results in a program crash
0
-#     # :error:: A handleable error condition
0
-#     # :warn:: A warning
0
-#     # :info:: generic (useful) information about system operation
0
-#     # :debug:: low-level information for developers
0
-#     Levels = 
0
-#     {
0
-#       :fatal => 7, 
0
-#       :error => 6, 
0
-#       :warn  => 4,
0
-#       :info  => 3,
0
-#       :debug => 0
0
-#     } unless const_defined?(:Levels)
0
-# 
0
-#     private
0
-# 
0
-#     # Readies a log for writing.
0
-#     #
0
-#     # ==== Parameters
0
-#     # log<IO, String>:: Either an IO object or a name of a logfile.
0
-#     def initialize_log(log)
0
-#       close if @log # be sure that we don't leave open files laying around.
0
-# 
0
-#       if log.respond_to?(:write)
0
-#         @log = log
0
-#       elsif File.exist?(log)
0
-#         @log = open(log, (File::WRONLY | File::APPEND))
0
-#         @log.sync = true
0
-#       else
0
-#         FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
0
-#         @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
0
-#         @log.sync = true
0
-#         @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
0
-#       end
0
-#     end
0
-# 
0
-#     public
0
-# 
0
-#     # To initialize the logger you create a new object, proxies to set_log.
0
-#     #
0
-#     # ==== Parameters
0
-#     # *args:: Arguments to create the log from. See set_logs for specifics.
0
-#     def initialize(*args)
0
-#       @init_args = args
0
-#       set_log(*args)
0
-#     end
0
-# 
0
-#     # Replaces an existing logger with a new one.
0
-#     # 
0
-#     # ==== Parameters
0
-#     # log<IO, String>:: Either an IO object or a name of a logfile.
0
-#     # log_level<~to_sym>::
0
-#     #   The log level from, e.g. :fatal or :info. Defaults to :error in the
0
-#     #   production environment and :debug otherwise.
0
-#     # delimiter<String>::
0
-#     #   Delimiter to use between message sections. Defaults to " ~ ".
0
-#     # auto_flush<Boolean>::
0
-#     #   Whether the log should automatically flush after new messages are
0
-#     #   added. Defaults to false.
0
-#     def set_log(log, log_level = nil, delimiter = " ~ ", auto_flush = false)
0
-#       if log_level && Levels[log_level.to_sym]
0
-#         @level = Levels[log_level.to_sym]
0
-#       elsif Merb.environment == "production"
0
-#         @level = Levels[:warn]
0
-#       else
0
-#         @level = Levels[:debug]
0
-#       end
0
-#       @buffer     = []
0
-#       @delimiter  = delimiter
0
-#       @auto_flush = auto_flush
0
-# 
0
-#       initialize_log(log)
0
-# 
0
-#       Merb.logger = self
0
-#     end
0
-# 
0
-#     # Flush the entire buffer to the log object.
0
-#     def flush
0
-#       return unless @buffer.size > 0
0
-#       @log.write(@buffer.slice!(0..-1).to_s)
0
-#     end
0
-# 
0
-#     # Close and remove the current log object.
0
-#     def close
0
-#       flush
0
-#       @log.close if @log.respond_to?(:close) && !@log.tty?
0
-#       @log = nil
0
-#     end
0
-# 
0
-#     # Appends a message to the log. The methods yield to an optional block and
0
-#     # the output of this block will be appended to the message.
0
-#     #
0
-#     # ==== Parameters
0
-#     # string<String>:: The message to be logged. Defaults to nil.
0
-#     #
0
-#     # ==== Returns
0
-#     # String:: The resulting message added to the log file.
0
-#     def <<(string = nil)
0
-#       message = ""
0
-#       message << delimiter
0
-#       message << string if string
0
-#       message << "\n" unless message[-1] == ?\n
0
-#       @buffer << message
0
-#       flush if @auto_flush
0
-# 
0
-#       message
0
-#     end
0
-#     alias :push :<<
0
-# 
0
-#     # Generate the logging methods for Merb.logger for each log level.
0
-#     Levels.each_pair do |name, number|
0
-#       class_eval <<-LEVELMETHODS, __FILE__, __LINE__
0
-# 
0
-#       # Appends a message to the log if the log level is at least as high as
0
-#       # the log level of the logger.
0
-#       #
0
-#       # ==== Parameters
0
-#       # string<String>:: The message to be logged. Defaults to nil.
0
-#       #
0
-#       # ==== Returns
0
-#       # self:: The logger object for chaining.
0
-#       def #{name}(message = nil)
0
-#         self << message if #{number} >= level
0
-#         self
0
-#       end
0
-# 
0
-#       # Appends a message to the log if the log level is at least as high as
0
-#       # the log level of the logger. The bang! version of the method also auto
0
-#       # flushes the log buffer to disk.
0
-#       #
0
-#       # ==== Parameters
0
-#       # string<String>:: The message to be logged. Defaults to nil.
0
-#       #
0
-#       # ==== Returns
0
-#       # self:: The logger object for chaining.
0
-#       def #{name}!(message = nil)
0
-#         self << message if #{number} >= level
0
-#         flush if #{number} >= level
0
-#         self
0
-#       end
0
-# 
0
-#       # ==== Returns
0
-#       # Boolean:: True if this level will be logged by this logger.
0
-#       def #{name}?
0
-#         #{number} >= level
0
-#       end
0
-#       LEVELMETHODS
0
-#     end
0
-# 
0
-#   end
0
-#   
0
-# end
0
+# ==== Public Merb Logger API
0
+#
0
+# To replace an existing logger with a new one:
0
+#  Merb::Logger.set_log(log{String, IO},level{Symbol, String})
0
+#
0
+# Available logging levels are
0
+#   Merb::Logger::{ Fatal, Error, Warn, Info, Debug }
0
+#
0
+# Logging via:
0
+#   Merb.logger.fatal(message<String>,&block)
0
+#   Merb.logger.error(message<String>,&block)
0
+#   Merb.logger.warn(message<String>,&block)
0
+#   Merb.logger.info(message<String>,&block)
0
+#   Merb.logger.debug(message<String>,&block)
0
+#
0
+# Logging with autoflush:
0
+#   Merb.logger.fatal!(message<String>,&block)
0
+#   Merb.logger.error!(message<String>,&block)
0
+#   Merb.logger.warn!(message<String>,&block)
0
+#   Merb.logger.info!(message<String>,&block)
0
+#   Merb.logger.debug!(message<String>,&block)
0
+#
0
+# Flush the buffer to 
0
+#   Merb.logger.flush
0
+#
0
+# Remove the current log object
0
+#   Merb.logger.close
0
+# 
0
+# ==== Private Merb Logger API
0
+# 
0
+# To initialize the logger you create a new object, proxies to set_log.
0
+#   Merb::Logger.new(log{String, IO},level{Symbol, String})
0
+module Merb
0
+
0
+  class Logger
0
+
0
+    attr_accessor :level
0
+    attr_accessor :delimiter
0
+    attr_accessor :auto_flush
0
+    attr_reader   :buffer
0
+    attr_reader   :log
0
+    attr_reader   :init_args
0
+
0
+    # ==== Notes
0
+    # Ruby (standard) logger levels:
0
+    # :fatal:: An unhandleable error that results in a program crash
0
+    # :error:: A handleable error condition
0
+    # :warn:: A warning
0
+    # :info:: generic (useful) information about system operation
0
+    # :debug:: low-level information for developers
0
+    Levels = 
0
+    {
0
+      :fatal => 7, 
0
+      :error => 6, 
0
+      :warn  => 4,
0
+      :info  => 3,
0
+      :debug => 0
0
+    } unless const_defined?(:Levels)
0
+
0
+    @@mutex = {}
0
+
0
+    private
0
+
0
+    # Readies a log for writing.
0
+    #
0
+    # ==== Parameters
0
+    # log<IO, String>:: Either an IO object or a name of a logfile.
0
+    def initialize_log(log)
0
+      close if @log # be sure that we don't leave open files laying around.
0
+
0
+      if log.respond_to?(:write)
0
+        @log = log
0
+      elsif File.exist?(log)
0
+        @log = open(log, (File::WRONLY | File::APPEND))
0
+        @log.sync = true
0
+      else
0
+        FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))
0
+        @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
0
+        @log.sync = true
0
+        @log.write("#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\n")
0
+      end
0
+    end
0
+
0
+    public
0
+
0
+    # To initialize the logger you create a new object, proxies to set_log.
0
+    #
0
+    # ==== Parameters
0
+    # *args:: Arguments to create the log from. See set_logs for specifics.
0
+    def initialize(*args)
0
+      set_log(*args)
0
+    end
0
+
0
+    # Replaces an existing logger with a new one.
0
+    # 
0
+    # ==== Parameters
0
+    # log<IO, String>:: Either an IO object or a name of a logfile.
0
+    # log_level<~to_sym>::
0
+    #   The log level from, e.g. :fatal or :info. Defaults to :error in the
0
+    #   production environment and :debug otherwise.
0
+    # delimiter<String>::
0
+    #   Delimiter to use between message sections. Defaults to " ~ ".
0
+    # auto_flush<Boolean>::
0
+    #   Whether the log should automatically flush after new messages are
0
+    #   added. Defaults to false.
0
+    def set_log(stream = Merb::Config[:log_stream],
0
+      log_level = Merb::Config[:log_level], 
0
+      delimiter = Merb::Config[:log_delimiter], 
0
+      auto_flush = Merb::Config[:log_auto_flush])
0
+      
0
+      @buffer                   = []
0
+      @delimiter                = delimiter
0
+      @auto_flush               = auto_flush
0
+      
0
+      if Levels[log_level]
0
+        @level                  = Levels[log_level]
0
+      else
0
+        @level                  = log_level
0
+      end
0
+
0
+      @log                      = stream
0
+      @mutex = (@@mutex[@log] ||= Mutex.new)
0
+    end
0
+
0
+    # Flush the entire buffer to the log object.
0
+    def flush
0
+      return unless @buffer.size > 0
0
+      @mutex.synchronize do
0
+        @log.write(@buffer.slice!(0..-1).to_s)
0
+      end
0
+    end
0
+
0
+    # Close and remove the current log object.
0
+    def close
0
+      flush
0
+      @log.close if @log.respond_to?(:close) && !@log.tty?
0
+      @log = nil
0
+    end
0
+
0
+    # Appends a message to the log. The methods yield to an optional block and
0
+    # the output of this block will be appended to the message.
0
+    #
0
+    # ==== Parameters
0
+    # string<String>:: The message to be logged. Defaults to nil.
0
+    #
0
+    # ==== Returns
0
+    # String:: The resulting message added to the log file.
0
+    def <<(string = nil)
0
+      message = ""
0
+      message << delimiter
0
+      message << string if string
0
+      message << "\n" unless message[-1] == ?\n
0
+      @buffer << message
0
+      flush if @auto_flush
0
+
0
+      message
0
+    end
0
+    alias :push :<<
0
+
0
+    # Generate the logging methods for Merb.logger for each log level.
0
+    Levels.each_pair do |name, number|
0
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
0
+
0
+      # Appends a message to the log if the log level is at least as high as
0
+      # the log level of the logger.
0
+      #
0
+      # ==== Parameters
0
+      # string<String>:: The message to be logged. Defaults to nil.
0
+      #
0
+      # ==== Returns
0
+      # self:: The logger object for chaining.
0
+      def #{name}(message = nil)
0
+        self << message if #{number} >= level
0
+        self
0
+      end
0
+
0
+      # Appends a message to the log if the log level is at least as high as
0
+      # the log level of the logger. The bang! version of the method also auto
0
+      # flushes the log buffer to disk.
0
+      #
0
+      # ==== Parameters
0
+      # string<String>:: The message to be logged. Defaults to nil.
0
+      #
0
+      # ==== Returns
0
+      # self:: The logger object for chaining.
0
+      def #{name}!(message = nil)
0
+        self << message if #{number} >= level
0
+        flush if #{number} >= level
0
+        self
0
+      end
0
+
0
+      # ==== Returns
0
+      # Boolean:: True if this level will be logged by this logger.
0
+      def #{name}?
0
+        #{number} >= level
0
+      end
0
+      LEVELMETHODS
0
+    end
0
+
0
+  end
0
+  
0
+end

0
@@ -3,6 +3,7 @@ module Merb
0
   module Rack
0
     autoload :Application,         'merb-core/rack/application'
0
     autoload :Adapter,             'merb-core/rack/adapter'
0
+    autoload :AbstractAdapter,     'merb-core/rack/adapter/abstract'
0
     autoload :Ebb,                 'merb-core/rack/adapter/ebb'
0
     autoload :EventedMongrel,      'merb-core/rack/adapter/evented_mongrel'    
0
     autoload :FastCGI,             'merb-core/rack/adapter/fcgi'

0
@@ -11,7 +11,11 @@ module Merb
0
         # ==== Returns.
0
         # Class:: The adapter class.
0
         def get(id)
0
-          Object.full_const_get(@adapters[id])
0
+          if @adapters[id.to_s]
0
+            Object.full_const_get(@adapters[id.to_s])
0
+          else
0
+            Merb.fatal! "The adapter #{id} did not exist"
0
+          end
0
         end
0
 
0
         # Registers a new Rack adapter.
0
@@ -36,9 +40,8 @@ module Merb
0
     Adapter.register %w{runner},         :Runner
0
     Adapter.register %w{smongrel swift}, :SwiftipliedMongrel
0
     Adapter.register %w{thin},           :Thin
0
-    Adapter.register %w{thin-turbo},     :ThinTurbo
0
+    Adapter.register %w{thin-turbo tt},  :ThinTurbo
0
     Adapter.register %w{webrick},        :WEBrick
0
     
0
   end # Rack
0
-end # Merb
0
-
0
+end # Merb
0
\ No newline at end of file

0
@@ -3,22 +3,21 @@ module Merb
0
   
0
   module Rack
0
 
0
-    class Ebb
0
+    class Ebb < Merb::Rack::AbstractAdapter
0
       # start an Ebb server on given host and port.
0
       
0
-      # ==== Parameters
0
-      # opts<Hash>:: Options for Ebb (see below).
0
-      #
0
-      # ==== Options (opts)
0
-      # :host<String>:: The hostname that Ebb should serve.
0
-      # :port<Fixnum>:: The port Ebb should bind to.
0
-      # :app:: The application
0
-      def self.start(opts={})
0
-        Merb.logger.warn!("Using Ebb adapter")
0
+      def self.new_server(port)
0
         Merb::Dispatcher.use_mutex = false
0
-        th = Thread.new { ::Ebb.start_server(opts[:app], opts) }
0
-        Merb::Server.change_privilege
0
-        th.join
0
+        opts = @opts.merge(:port => port)
0
+        @th = Thread.new { Thread.current[:server] = ::Ebb.start_server(opts[:app], opts) }
0
+      end
0
+      
0
+      def self.start_server
0
+        @th.join
0
+      end
0
+      
0
+      def self.stop(status = 0)
0
+        ::Ebb.stop_server
0
       end
0
     end
0
   end

0
@@ -4,22 +4,9 @@ module Merb
0
   module Rack
0
 
0
     class EventedMongrel < Mongrel
0
-      # Starts Mongrel as evented.
0
-      #
0
-      # ==== Parameters
0
-      # opts<Hash>:: Options for Mongrel (see below).
0
-      #
0
-      # ==== Options (opts)
0
-      # :host<String>:: The hostname that Mongrel should serve.
0
-      # :port<Fixnum>:: The port Mongrel should bind to.
0
-      # :app<String>>:: The application name.
0
-      def self.start(opts={})
0
-        Merb.logger.warn!("Using EventedMongrel adapter")
0
+      def self.new_server(port)
0
         Merb::Dispatcher.use_mutex = false
0
-        server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i)
0
-        Merb::Server.change_privilege
0
-        server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app]))
0
-        server.run.join
0
+        super
0
       end
0
     end
0
   end