wycats-merb-core 0.9.8 → 0.9.9

data/lib/merb-core/rack.rb

@@ -3,6 +3,7 @@ module Merb
   module Rack
     autoload :Application,         'merb-core/rack/application'
     autoload :Adapter,             'merb-core/rack/adapter'
+    autoload :AbstractAdapter,     'merb-core/rack/adapter/abstract'
     autoload :Ebb,                 'merb-core/rack/adapter/ebb'
     autoload :EventedMongrel,      'merb-core/rack/adapter/evented_mongrel'    
     autoload :FastCGI,             'merb-core/rack/adapter/fcgi'
@@ -21,5 +22,6 @@ module Merb
     autoload :ContentLength,       'merb-core/rack/middleware/content_length'
     autoload :ConditionalGet,      'merb-core/rack/middleware/conditional_get'
     autoload :Csrf,                'merb-core/rack/middleware/csrf'
+    autoload :StreamWrapper,       'merb-core/rack/stream_wrapper'
   end # Rack
-end # Merb
+end # Merb

data/lib/merb-core/rack/adapter.rb

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

data/lib/merb-core/rack/adapter/ebb.rb

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

data/lib/merb-core/rack/adapter/evented_mongrel.rb

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

data/lib/merb-core/rack/adapter/irb.rb

@@ -10,8 +10,9 @@ module Merb
       #
       # ==== Alternatives
       # If name is a hash, it will be merged with params.
-      def url(name, params={})
-        Merb::Router.generate(name, params)
+      def url(name, *args)
+        args << {}
+        Merb::Router.url(name, *args)
       end
 
       # Reloads classes using Merb::BootLoader::ReloadClasses.

data/lib/merb-core/rack/adapter/mongrel.rb

@@ -4,23 +4,30 @@ module Merb
 
   module Rack
 
-    class Mongrel
-      # start server on given host and port.
+    class Mongrel < Merb::Rack::AbstractAdapter
+
+      def self.stop(status = 0)
+        if @server
+          begin
+            @server.stop(true)
+          rescue Mongrel::TimeoutError
+            Merb.logger.fatal! "Your process took too long to shut " \
+              "down, so mongrel killed it."
+          end
+          true
+        end
+      end
       
-      # ==== Parameters
-      # opts<Hash>:: Options for Mongrel (see below).
-      #
-      # ==== Options (opts)
-      # :host<String>:: The hostname that Mongrel should serve.
-      # :port<Fixnum>:: The port Mongrel should bind to.
-      # :app<String>>:: The application name.
-      def self.start(opts={})
-        Merb.logger.warn!("Using Mongrel adapter")
-        server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i)
-        Merb::Server.change_privilege
-        server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app]))
-        server.run.join
+      def self.new_server(port)
+        @server = ::Mongrel::HttpServer.new(@opts[:host], port)
       end
+      
+      def self.start_server
+        @server.register('/', ::Merb::Rack::Handler::Mongrel.new(@opts[:app]))
+        @server.run.join
+      end
+      
     end
+    
   end
 end

data/lib/merb-core/rack/adapter/swiftiplied_mongrel.rb

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

data/lib/merb-core/rack/adapter/thin.rb

@@ -4,35 +4,34 @@ module Merb
 
   module Rack
 
-    class Thin
+    class Thin < Merb::Rack::AbstractAdapter
       # start a Thin server on given host and port.
 
-      # ==== Parameters
-      # opts<Hash>:: Options for Thin (see below).
-      #
-      # ==== Options (opts)
-      # :host<String>:: The hostname that Thin should serve.
-      # :port<Fixnum>:: The port Thin should bind to.
-      # :socket<Fixnum>>:: The socket number that thin should bind to.
-      # :socket_file<String>>:: The socket file that thin should attach to.
-      # :app<String>>:: The application name.
-      def self.start(opts={})
+      def self.new_server(port)
         Merb::Dispatcher.use_mutex = false
-        if opts[:socket] || opts[:socket_file]
-          socket = opts[:socket] || "0"
-          socket_file = opts[:socket_file] || "#{Merb.root}/log/merb.#{socket}.sock"
+        
+        if (@opts[:socket] || @opts[:socket_file])
+          socket = port.to_s
+          socket_file = @opts[:socket_file] || "#{Merb.log_path}/#{Merb::Config[:name]}.#{socket}.sock"
           Merb.logger.warn!("Using Thin adapter with socket file #{socket_file}.")
-          server = ::Thin::Server.new(socket_file, opts[:app], opts)
+          @server = ::Thin::Server.new(socket_file, @opts[:app], @opts)
         else
-          Merb.logger.warn!("Using Thin adapter on host #{opts[:host]} and port #{opts[:port]}.")
-          if opts[:host].include?('/')
-            opts[:host] = "#{opts[:host]}-#{opts[:port]}"
-          end
-          server = ::Thin::Server.new(opts[:host], opts[:port].to_i, opts[:app], opts)
+          Merb.logger.warn!("Using Thin adapter on host #{@opts[:host]} and port #{port}.")
+          @opts[:host] = "#{@opts[:host]}-#{port}" if @opts[:host].include?('/')
+          @server = ::Thin::Server.new(@opts[:host], port, @opts[:app], @opts)
         end
-        Merb::Server.change_privilege
+      end
+
+      def self.start_server
         ::Thin::Logging.silent = true
-        server.start
+        @server.start
+      end
+      
+      def self.stop(status = 0)
+        if @server
+          @server.stop
+          true
+        end
       end
     end
   end

data/lib/merb-core/rack/adapter/thin_turbo.rb

@@ -7,18 +7,11 @@ module Merb
     class ThinTurbo < Thin
       # start a Thin Turbo server on given host and port.
 
-      # ==== Parameters
-      # opts<Hash>:: Options for Thin Turbo (see below).
-      #
-      # ==== Options (opts)
-      # :host<String>:: The hostname that Thin Turbo should serve.
-      # :port<Fixnum>:: The port Thin Turbo should bind to.
-      # :socket<Fixnum>>:: The socket number that thin should bind to.
-      # :socket_file<String>>:: The socket file that thin should attach to.
-      # :app<String>>:: The application name.
-      def self.start(opts={})
-        super(opts.merge(:backend => ::Thin::Backends::Turbo))
+      def self.new_server(port)
+        @opts.merge!(:backend => ::Thin::Backends::Turbo)
+        super
       end
+
     end
   end
 end

data/lib/merb-core/rack/adapter/webrick.rb

@@ -1,36 +1,72 @@
 require 'webrick'
+require 'webrick/utils'
 require 'rack/handler/webrick'
 module Merb
   module Rack
 
-    class WEBrick
-      # start WEBrick server on given host and port.
+    class WEBrick < Merb::Rack::AbstractAdapter
       
-      # ==== Parameters
-      # opts<Hash>:: Options for WEBrick (see below).
-      #
-      # ==== Options (opts)
-      # :host<String>:: The hostname that WEBrick should serve.
-      # :port<Fixnum>:: The port WEBrick should bind to.
-      # :app<String>>:: The application name.
-      def self.start(opts={})
-        Merb.logger.warn!("Using Webrick adapter")
+      class << self
+        attr_accessor :server
+      end
       
+      def self.new_server(port)
         options = {
-          :Port        => opts[:port],
-          :BindAddress => opts[:host],
+          :Port        => port,
+          :BindAddress => @opts[:host],
           :Logger      => Merb.logger,
           :AccessLog   => [
             [Merb.logger, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
             [Merb.logger, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
           ]
         }
-     
-        server = ::WEBrick::HTTPServer.new(options)
-        Merb::Server.change_privilege
-        server.mount("/", ::Rack::Handler::WEBrick, opts[:app])
-        server.start
+
+        sockets = ::WEBrick::Utils.create_listeners nil, port
+        @server = ::WEBrick::HTTPServer.new(options.merge(:DoNotListen => true))
+        @server.listeners.replace sockets
       end
+      
+      def self.start_server
+        @server.mount("/", ::Rack::Handler::WEBrick, @opts[:app])
+        @server.start
+        exit(@status)
+      end
+      
+      def self.stop(status = 0)
+        @status = status
+        @server.shutdown
+      end
+      
+      def self.exit_process(status = 0)
+      end      
+      
+      # start WEBrick server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for WEBrick (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that WEBrick should serve.
+      # :port<Fixnum>:: The port WEBrick should bind to.
+      # :app<String>>:: The application name.
+      # def self.start(opts={})
+      #   Merb.logger.warn!("Using Webrick adapter")
+      # 
+      #   options = {
+      #     :Port        => opts[:port],
+      #     :BindAddress => opts[:host],
+      #     :Logger      => Merb.logger,
+      #     :AccessLog   => [
+      #       [Merb.logger, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+      #       [Merb.logger, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+      #     ]
+      #   }
+      #      
+      #   server = ::WEBrick::HTTPServer.new(options)
+      #   Merb::Server.change_privilege
+      #   server.mount("/", ::Rack::Handler::WEBrick, opts[:app])
+      #   server.start
+      # end
     end
   end
 end

data/lib/merb-core/rack/handler/mongrel.rb

@@ -32,11 +32,15 @@ module Merb
         #   The hostname on which the app should run. Defaults to "0.0.0.0"
         # :Port<Fixnum>:: The port for the app. Defaults to 8080.
         def self.run(app, options={})
-          server = ::Mongrel::HttpServer.new(options[:Host] || '0.0.0.0',
+          @server = ::Mongrel::HttpServer.new(options[:Host] || '0.0.0.0',
                                              options[:Port] || 8080)
-          server.register('/', ::Merb::Rack::Handler::Mongrel.new(app))
-          yield server  if block_given?
-          server.run.join
+          @server.register('/', ::Merb::Rack::Handler::Mongrel.new(app))
+          yield @server  if block_given?
+          @server.run.join
+        end
+  
+        def self.stop(block = true)
+          @server.stop
         end
   
         # ==== Parameters
@@ -63,8 +67,7 @@ module Merb
                        "rack.multiprocess" => false, # ???
                        "rack.run_once" => false,
   
-                       "rack.url_scheme" => "http",
-                       "rack.streaming" => true
+                       "rack.url_scheme" => "http"
                      })
           env["QUERY_STRING"] ||= ""
           env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
@@ -79,13 +82,9 @@ module Merb
               }
             }
             
-            if Proc === body
-              body.call(response)
-            else  
-              body.each { |part|
-                response.body << part
-              }
-            end
+            body.each { |part|
+              response.body << part
+            }
             response.finished
           ensure
             body.close  if body.respond_to? :close

data/lib/merb-core/rack/middleware/csrf.rb

@@ -10,7 +10,7 @@ module Merb
 
       def call(env)
         status, header, body = @app.call(env)
-
+        body = body.to_s
         if env[Merb::Const::REQUEST_METHOD] == Merb::Const::GET
           body = process_response(body) if valid_content_type?(header[Merb::Const::CONTENT_TYPE])
         elsif env[Merb::Const::REQUEST_METHOD] == Merb::Const::POST

data/lib/merb-core/server.rb

@@ -1,4 +1,5 @@
 require 'etc'
+
 module Merb
 
   # Server encapsulates the management of Merb daemons.
@@ -18,46 +19,25 @@ module Merb
       # If cluster is left out, then one process will be started. This process
       # will be daemonized if Merb::Config[:daemonize] is true.
       def start(port, cluster=nil)
+        
         @port = port
-        @cluster = cluster
-        if @cluster
-          @port.to_i.upto(@port.to_i + @cluster.to_i-1) do |port|
-            pidfile = pid_file(port)
-            pid = IO.read(pidfile).chomp.to_i if File.exist?(pidfile)
+        @cluster = cluster        
 
-            unless alive?(port)
-              remove_pid_file(port)
-              puts "Starting merb server on port #{port}, pid file: #{pidfile} and process id is #{pid}" if Merb::Config[:verbose]
-              daemonize(port)
-            else
-              raise "Merb is already running: port is #{port}, pid file: #{pidfile}, process id is #{pid}"
-            end
-          end
-        elsif Merb::Config[:daemonize]
+        if Merb::Config[:daemonize]
           pidfile = pid_file(port)
-          pid = IO.read(pidfile).chomp.to_i if File.exist?(pidfile)
+          pid = File.read(pidfile).chomp.to_i if File.exist?(pidfile)
 
           unless alive?(@port)
             remove_pid_file(@port)
             puts "Daemonizing..." if Merb::Config[:verbose]
             daemonize(@port)
           else
-            raise "Merb is already running: port is #{port}, pid file: #{pidfile}, process id is #{pid}"
+            Merb.fatal! "Merb is already running on port #{port}.\n" \
+              "\e[0m   \e[1;31;47mpid file: \e[34;47m#{pidfile}" \
+              "\e[1;31;47m, process id is \e[34;47m#{pid}."
           end
         else
-          trap('TERM') { exit }
-
-          if Merb::Config[:console_trap]
-            add_irb_trap
-          else
-            trap('INT') { puts "\nExiting"; exit }
-          end
-
-          puts "Running bootloaders..." if Merb::Config[:verbose]
-          BootLoader.run
-          puts "Starting Rack adapter..." if Merb::Config[:verbose]
-          Merb.logger.info! "Starting Merb server listening at #{Merb::Config[:host]}:#{port}"
-          Merb.adapter.start(Merb::Config.to_hash)
+          bootup
         end
       end
 
@@ -71,12 +51,14 @@ module Merb
         puts "About to check if port #{port} is alive..." if Merb::Config[:verbose]
         pidfile = pid_file(port)
         puts "Pidfile is #{pidfile}..." if Merb::Config[:verbose]
-        pid = IO.read(pidfile).chomp.to_i
+        pid = File.read(pidfile).chomp.to_i
         puts "Process id is #{pid}" if Merb::Config[:verbose]
         Process.kill(0, pid)
         true
-      rescue
+      rescue Errno::ESRCH, Errno::ENOENT
         false
+      rescue Errno::EACCES => e
+        Merb.fatal!("You don't have access to the PID file at #{pidfile}.", e)
       end
 
       # ==== Parameters
@@ -86,32 +68,51 @@ module Merb
       # ==== Alternatives
       # If you pass "all" as the port, the signal will be sent to all Merb
       # processes.
-      def kill(port, sig=9)
+      def kill(port, sig="INT")
         Merb::BootLoader::BuildFramework.run
-        begin
-          pidfiles = port == "all" ?
-            pid_files : [ pid_file(port) ]
+        if sig == 9 && port == "main"
+          kill_pid("INT", pid_file("main"))
+          Dir["#{Merb.log_path}" / "*.pid"].each do |file|
+            kill_pid(9, file)
+          end
+        else
+          kill_pid(sig, pid_file(port))
+        end
+
+        if sig.is_a?(Integer)
+          sig = Signal.list.invert[sig]
+        end
 
-          pidfiles.each do |f|
-            pid = IO.read(f).chomp.to_i
-            begin
-              Process.kill(sig, pid)
-              FileUtils.rm(f) if File.exist?(f)
-              puts "killed PID #{pid} with signal #{sig}"
-            rescue Errno::EINVAL
-              puts "Failed to kill PID #{pid}: '#{sig}' is an invalid or unsupported signal number."
-            rescue Errno::EPERM
-              puts "Failed to kill PID #{pid}: Insufficient permissions."
-            rescue Errno::ESRCH
-              puts "Failed to kill PID #{pid}: Process is deceased or zombie."
-              FileUtils.rm f
-            rescue Exception => e
-              puts "Failed to kill PID #{pid}: #{e.message}"
-            end
+        if sig == "KILL" && port == "main"
+          Merb.fatal! "Killed all PIDs with signal KILL"
+        else
+          Merb.fatal! "Killed #{port} with signal #{sig}"
+        end
+      end
+      
+      def kill_pid(sig, file)
+        begin
+          pid = File.read(file).chomp.to_i
+          Merb.logger.warn! "Killing pid #{pid}"
+          Process.kill(sig, pid)
+          FileUtils.rm(file) if File.exist?(file)
+        rescue Errno::EINVAL
+          Merb.fatal! "Failed to kill PID #{pid}: '#{sig}' is an invalid " \
+            "or unsupported signal number."
+        rescue Errno::EPERM
+          Merb.fatal! "Failed to kill PID #{pid}: Insufficient permissions."
+        rescue Errno::ESRCH
+          FileUtils.rm file
+          Merb.fatal! "Failed to kill PID #{pid}: Process is " \
+            "deceased or zombie."
+        rescue Errno::EACCES => e
+          Merb.fatal! e.message, e
+        rescue Errno::ENOENT => e
+          Merb.fatal! "Could not find a PID file at #{file}", e
+        rescue Exception => e
+          if !e.is_a?(SystemExit)
+            Merb.fatal! "Failed to kill PID #{pid}", e
           end
-        ensure
-          Merb.started = false
-          exit
         end
       end
 
@@ -122,28 +123,45 @@ module Merb
         fork do
           Process.setsid
           exit if fork
+          Merb.logger.warn! "In #{Process.pid}" if Merb.logger
           File.umask 0000
           STDIN.reopen "/dev/null"
           STDOUT.reopen "/dev/null", "a"
           STDERR.reopen STDOUT
-          trap("TERM") { exit }
-          Dir.chdir Merb::Config[:merb_root]
+          begin
+            Dir.chdir Merb::Config[:merb_root]
+          rescue Errno::EACCES => e
+            Merb.fatal! "You specified #{Merb::Config[:merb_root]} " \
+              "as the Merb root, but you did not have access to it.", e
+          end
           at_exit { remove_pid_file(port) }
           Merb::Config[:port] = port
-          BootLoader.run
-          Merb.adapter.start(Merb::Config.to_hash)
+          bootup
         end
+      rescue NotImplementedError => e
+        Merb.fatal! "Daemonized mode is not supported on your platform", e
+      end
+
+      def bootup
+        Merb.trap('TERM') { exit }
+
+        puts "Running bootloaders..." if Merb::Config[:verbose]
+        BootLoader.run
+        puts "Starting Rack adapter..." if Merb::Config[:verbose]
+        Merb.adapter.start(Merb::Config.to_hash)
       end
 
       def change_privilege
-        if Merb::Config[:user]
-          if Merb::Config[:group]
-            puts "About to change privilege to group #{Merb::Config[:group]} and user #{Merb::Config[:user]}" if Merb::Config[:verbose]
-            _change_privilege(Merb::Config[:user], Merb::Config[:group])
-          else
-            puts "About to change privilege to user #{Merb::Config[:user]}" if Merb::Config[:verbose]
-            _change_privilege(Merb::Config[:user])
-          end
+        if Merb::Config[:user] && Merb::Config[:group]
+          Merb.logger.verbose! "About to change privilege to group " \
+            "#{Merb::Config[:group]} and user #{Merb::Config[:user]}"
+          _change_privilege(Merb::Config[:user], Merb::Config[:group])
+        elsif Merb::Config[:user]
+          Merb.logger.verbose! "About to change privilege to user " \
+            "#{Merb::Config[:user]}"
+          _change_privilege(Merb::Config[:user])
+        else
+          return true
         end
       end
 
@@ -160,8 +178,10 @@ module Merb
       # instead of the port based PID file.
       def remove_pid_file(port)
         pidfile = pid_file(port)
-        puts "Removing pid file #{pidfile} (port is #{port})..."
-        FileUtils.rm(pidfile) if File.exist?(pidfile)
+        if File.exist?(pidfile)
+          puts "Removing pid file #{pidfile} (port is #{port})..."
+          FileUtils.rm(pidfile)
+        end
       end
 
       # Stores a PID file on the filesystem.
@@ -176,11 +196,23 @@ module Merb
       # If Merb::Config[:pid_file] has been specified, that will be used
       # instead of the port based PID file.
       def store_pid(port)
-        pidfile = pid_file(port)
-        puts "Storing pid file to #{pidfile}..."
-        FileUtils.mkdir_p(File.dirname(pidfile)) unless File.directory?(File.dirname(pidfile))
-        puts "Created directory, writing process id..." if Merb::Config[:verbose]
-        File.open(pidfile, 'w'){ |f| f.write("#{Process.pid}") }
+        store_details(port)
+      end
+
+      def remove_pid(port)
+        FileUtils.rm(pid_file(port)) if File.file?(pid_file(port))
+      end
+
+      def store_details(port = nil)
+        file = pid_file(port)
+        begin
+          FileUtils.mkdir_p(File.dirname(file))
+        rescue Errno::EACCES => e
+          Merb.fatal! "You tried to store Merb logs in #{File.dirname(file)}, " \
+            "but you did not have access.", e
+        end
+        Merb.logger.warn! "Storing #{type} file to #{file}..." if Merb::Config[:verbose]
+        File.open(file, 'w'){ |f| f.write(Process.pid.to_s) }
       end
 
       # Gets the pid file for the specified port.
@@ -194,20 +226,8 @@ module Merb
       #   Location of pid file for specified port. If clustered and pid_file option
       #   is specified, it adds the port value to the path.
       def pid_file(port)
-        if Merb::Config[:pid_file]
-          pidfile = Merb::Config[:pid_file]
-          if Merb::Config[:cluster]
-            ext = File.extname(Merb::Config[:pid_file])
-            base = File.basename(Merb::Config[:pid_file], ext)
-            dir = File.dirname(Merb::Config[:pid_file])
-            File.join(dir, "#{base}.#{port}#{ext}")
-          else
-            Merb::Config[:pid_file]
-          end
-        else
-          pidfile = Merb.log_path / "merb.#{port}.pid"
-          Merb.log_path / "merb.#{port}.pid"
-        end
+        pidfile = Merb::Config[:pid_file] || (Merb.log_path / "merb.%s.pid")
+        pidfile % port
       end
 
       # Get a list of the pid files.
@@ -218,10 +238,7 @@ module Merb
       def pid_files
         if Merb::Config[:pid_file]
           if Merb::Config[:cluster]
-            ext = File.extname(Merb::Config[:pid_file])
-            base = File.basename(Merb::Config[:pid_file], ext)
-            dir = File.dirname(Merb::Config[:pid_file])
-            Dir[dir / "#{base}.*#{ext}"]
+            Dir[Merb::Config[:pid_file] % "*"]
           else
             [ Merb::Config[:pid_file] ]
           end
@@ -240,11 +257,25 @@ module Merb
       # If group is left out, the user will be used as the group.
       def _change_privilege(user, group=user)
 
-        puts "Changing privileges to #{user}:#{group}"
+        Merb.logger.warn! "Changing privileges to #{user}:#{group}"
 
         uid, gid = Process.euid, Process.egid
-        target_uid = Etc.getpwnam(user).uid
-        target_gid = Etc.getgrnam(group).gid
+        
+        begin
+          target_uid = Etc.getpwnam(user).uid
+        rescue ArgumentError => e
+          Merb.fatal!(
+            "You tried to use user #{user}, but no such user was found", e)
+          return false
+        end
+        
+        begin
+          target_gid = Etc.getgrnam(group).gid
+        rescue ArgumentError => e
+          Merb.fatal!(
+            "You tried to use group #{group}, but no such group was found", e)
+          return false
+        end
 
         if uid != target_uid || gid != target_gid
           # Change process ownership
@@ -252,13 +283,19 @@ module Merb
           Process::GID.change_privilege(target_gid)
           Process::UID.change_privilege(target_uid)
         end
+        true
       rescue Errno::EPERM => e
-        puts "Couldn't change user and group to #{user}:#{group}: #{e}"
+        Merb.fatal! "Couldn't change user and group to #{user}:#{group}", e
+        false
       end
 
       def add_irb_trap
-        trap('INT') do
-          exit if @interrupted
+        Merb.trap('INT') do
+          if @interrupted
+            puts "Exiting\n"
+            exit
+          end
+
           @interrupted = true
           puts "Interrupt a second time to quit"
           Kernel.sleep 1.5
@@ -271,7 +308,7 @@ module Merb
             IRB.conf[:MAIN_CONTEXT] = @irb.context
           end
 
-          trap(:INT) { @irb.signal_handle }
+          Merb.trap(:INT) { @irb.signal_handle }
           catch(:IRB_EXIT) { @irb.eval_input }
 
           puts "Exiting IRB mode, back in server mode"