thorero 0.9.4.4 → 0.9.4.5

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

@@ -0,0 +1,28 @@
+module Merb
+  
+  module Rack
+    
+    class Runner
+      # ==== Parameters
+      # opts<Hash>:: Options for the runner (see below).
+      #
+      # ==== Options (opts)
+      # :runner_code<String>:: The code to run.
+      #
+      # ==== Notes
+      # If opts[:runner_code] matches a filename, that file will be read and
+      # the contents executed. Otherwise the code will be executed directly.
+      def self.start(opts={})
+        Merb::Server.change_privilege
+        if opts[:runner_code]
+          if File.exists?(opts[:runner_code])
+            eval(File.read(opts[:runner_code]), TOPLEVEL_BINDING, __FILE__, __LINE__)
+          else
+            eval(opts[:runner_code], TOPLEVEL_BINDING, __FILE__, __LINE__)
+          end
+          exit
+        end  
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'swiftcore/swiftiplied_mongrel'
+require 'merb-core/rack/handler/mongrel'
+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")
+        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
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "thin"
+
+module Merb
+
+  module Rack
+
+    class Thin
+      # 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={})
+        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"
+          Merb.logger.warn!("Using Thin adapter with socket file #{socket_file}.")
+          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)
+        end
+        Merb::Server.change_privilege
+        ::Thin::Logging.silent = true
+        server.start
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "thin-turbo"
+
+module Merb
+
+  module Rack
+
+    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))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'webrick'
+require 'rack/handler/webrick'
+module Merb
+  module Rack
+
+    class WEBrick
+      # 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/application.rb

@@ -0,0 +1,18 @@
+module Merb  
+  module Rack
+    class Application
+      
+      def call(env) 
+        begin
+          controller = ::Merb::Dispatcher.handle(env)
+        rescue Object => e
+          return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
+        end
+        Merb.logger.info "\n\n"
+        Merb.logger.flush
+        [controller.status, controller.headers, controller.body]
+      end
+      
+    end
+  end  
+end

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

@@ -0,0 +1,97 @@
+require 'stringio'
+class Mongrel::HttpResponse
+  NO_CLOSE_STATUS_FORMAT = "HTTP/1.1 %d %s\r\n".freeze
+
+  # Sends the status to the client without closing the connection.
+  #
+  # ==== Parameters
+  # content_length<Fixnum>:: The length of the content. Defaults to body length.
+  def send_status_no_connection_close(content_length=@body.length)
+    unless @status_sent
+      write(NO_CLOSE_STATUS_FORMAT % [@status, Mongrel::HTTP_STATUS_CODES[@status]])
+      @status_sent = true
+    end
+  end
+end
+
+module Merb
+  module Rack
+    module Handler
+      class Mongrel < ::Mongrel::HttpHandler
+        # Runs the server and yields it to a block.
+        #
+        # ==== Parameters
+        # app<Merb::Rack::Application>:: The app that Mongrel should handle.
+        # options<Hash>:: Options to pass to Mongrel (see below).
+        #
+        # ==== Block parameters
+        # server<Mongrel::HttpServer>:: The server to run.
+        #
+        # ==== Options (options)
+        # :Host<String>::
+        #   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',
+                                             options[:Port] || 8080)
+          server.register('/', ::Merb::Rack::Handler::Mongrel.new(app))
+          yield server  if block_given?
+          server.run.join
+        end
+  
+        # ==== Parameters
+        # app<Merb::Rack::Application>:: The app that Mongrel should handle.
+        def initialize(app)
+          @app = app
+        end
+
+        # ==== Parameters
+        # request<Merb::Request>:: The HTTP request to handle.
+        # response<HTTPResponse>:: The response object to write response to.
+        def process(request, response)
+          env = {}.replace(request.params)
+          env.delete "HTTP_CONTENT_TYPE"
+          env.delete "HTTP_CONTENT_LENGTH"
+  
+          env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+  
+          env.update({"rack.version" => [0,1],
+                       "rack.input" => request.body || StringIO.new(""),
+                       "rack.errors" => STDERR,
+  
+                       "rack.multithread" => true,
+                       "rack.multiprocess" => false, # ???
+                       "rack.run_once" => false,
+  
+                       "rack.url_scheme" => "http",
+                       "rack.streaming" => true
+                     })
+          env["QUERY_STRING"] ||= ""
+          env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
+  
+          status, headers, body = @app.call(env)
+  
+          begin
+            response.status = status.to_i
+            headers.each { |k, vs|
+              vs.each { |v|
+                response.header[k] = v
+              }
+            }
+            
+            if Proc === body
+              body.call(response)
+            else  
+              body.each { |part|
+                response.body << part
+              }
+            end
+            response.finished
+          ensure
+            body.close  if body.respond_to? :close
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Merb
+  module Rack
+    class Middleware
+      
+      def initialize(app)
+        @app = app
+      end
+      
+      def deferred?(env)
+        path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : ""
+        if path =~ Merb.deferred_actions
+          Merb.logger.info! "Deferring Request: #{path}"
+          true
+        else
+          false
+        end
+      end
+  
+      def call(env)
+        @app.call(env)
+      end
+      
+    end
+  end
+end
+

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

@@ -0,0 +1,31 @@
+module Merb
+  module Rack
+    class PathPrefix < Merb::Rack::Middleware
+
+      def initialize(app, path_prefix = nil)
+        super(app)
+        @path_prefix = /^#{Regexp.escape(path_prefix)}/
+      end
+      
+      def deferred?(env)
+        strip_path_prefix(env) 
+        @app.deferred?(env)
+      end
+      
+      def call(env)
+        strip_path_prefix(env) 
+        @app.call(env)
+      end
+
+      def strip_path_prefix(env)
+        ['PATH_INFO', 'REQUEST_URI'].each do |path_key|
+          if env[path_key] =~ @path_prefix
+            env[path_key].sub!(@path_prefix, '')
+            env[path_key] = '/' if env[path_key].empty?
+          end
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Merb
+  module Rack
+    class Profiler < Merb::Rack::Middleware
+
+      def initialize(app, min=1, iter=1)
+        super(app)
+        @min, @iter = min, iter
+      end
+
+      def call(env)
+        __profile__("profile_output", @min, @iter) do
+          @app.call(env)
+        end
+      end
+
+      
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Merb
+  module Rack
+    class Static < Merb::Rack::Middleware
+
+      def initialize(app,directory)
+        super(app)
+        @static_server = ::Rack::File.new(directory)
+      end
+      
+      def call(env)        
+        path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : ""
+        cached_path = (path.empty? ? 'index' : path) + '.html'
+        
+        if file_exist?(path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the file if it's there and the request method is GET or HEAD
+          serve_static(env)
+        elsif file_exist?(cached_path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the page cache if it's there and the request method is GET or HEAD
+          env['PATH_INFO'] = cached_path
+          serve_static(env)
+        elsif path =~ /favicon\.ico/
+          return [404, {"Content-Type"=>"text/html"}, "404 Not Found."]
+        else
+          @app.call(env)
+        end
+      end
+      
+       # ==== Parameters
+        # path<String>:: The path to the file relative to the server root.
+        #
+        # ==== Returns
+        # Boolean:: True if file exists under the server root and is readable.
+        def file_exist?(path)
+          full_path = ::File.join(@static_server.root, ::Merb::Request.unescape(path))
+          ::File.file?(full_path) && ::File.readable?(full_path)
+        end
+
+        # ==== Parameters
+        # env<Hash>:: Environment variables to pass on to the server.
+        def serve_static(env)
+          env["PATH_INFO"] = ::Merb::Request.unescape(env["PATH_INFO"])        
+          @static_server.call(env)
+        end
+      
+    end
+  end
+end

data/lib/merb-core/server.rb

@@ -0,0 +1,252 @@
+require 'etc'
+module Merb
+
+  # Server encapsulates the management of Merb daemons.
+  class Server
+    class << self
+
+      # Start a Merb server, in either foreground, daemonized or cluster mode.
+      #
+      # ==== Parameters
+      # port<~to_i>::
+      #   The port to which the first server instance should bind to.
+      #   Subsequent server instances bind to the immediately following ports.
+      # cluster<~to_i>::
+      #   Number of servers to run in a cluster.
+      #
+      # ==== Alternatives
+      # 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)
+
+            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]
+          pidfile = pid_file(port)
+          pid = IO.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}"
+          end
+        else
+          trap('TERM') { exit }
+          trap('INT') { puts "\nExiting"; 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
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port to check for Merb instances on.
+      #
+      # ==== Returns
+      # Boolean::
+      #   True if Merb is running on the specified port.
+      def alive?(port)
+        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
+        puts "Process id is #{pid}" if Merb::Config[:verbose]
+        Process.kill(0, pid)
+        true
+      rescue
+        false
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port of the Merb process to kill.
+      # sig<~to_s>:: The signal to send to the process. Defaults to 9.
+      #
+      # ==== Alternatives
+      # If you pass "all" as the port, the signal will be sent to all Merb
+      # processes.
+      def kill(port, sig=9)
+        Merb::BootLoader::BuildFramework.run
+        begin
+          pidfiles = port == "all" ?
+            pid_files : [ pid_file(port) ]
+
+          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
+          end
+        ensure
+          exit
+        end
+      end
+
+      # ==== Parameters
+      # port<~to_s>:: The port of the Merb process to daemonize.
+      def daemonize(port)
+        puts "About to fork..." if Merb::Config[:verbose]
+        fork do
+          Process.setsid
+          exit if fork
+          File.umask 0000
+          STDIN.reopen "/dev/null"
+          STDOUT.reopen "/dev/null", "a"
+          STDERR.reopen STDOUT
+          trap("TERM") { exit }
+          Dir.chdir Merb::Config[:merb_root]
+          at_exit { remove_pid_file(port) }
+          Merb::Config[:port] = port
+          BootLoader.run
+          Merb.adapter.start(Merb::Config.to_hash)
+        end
+      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
+        end
+      end
+
+      # Removes a PID file used by the server from the filesystem.
+      # This uses :pid_file options from configuration when provided
+      # or merb.<port>.pid in log directory by default.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Alternatives
+      # If Merb::Config[:pid_file] has been specified, that will be used
+      # 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)
+      end
+
+      # Stores a PID file on the filesystem.
+      # This uses :pid_file options from configuration when provided
+      # or merb.<port>.pid in log directory by default.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Alternatives
+      # 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}") }
+      end
+
+      # Gets the pid file for the specified port.
+      #
+      # ==== Parameters
+      # port<~to_s>::
+      #   The port of the Merb process to whom the the PID file belongs to.
+      #
+      # ==== Returns
+      # String::
+      #   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
+      end
+
+      # Get a list of the pid files.
+      #
+      # ==== Returns
+      # Array::
+      #   List of pid file paths. If not clustered, array contains a single path.
+      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}"]
+          else
+            [ Merb::Config[:pid_file] ]
+          end
+        else
+          Dir[Merb.log_path / "merb.*.pid"]
+        end
+       end
+
+      # Change privileges of the process to the specified user and group.
+      #
+      # ==== Parameters
+      # user<String>:: The user who should own the server process.
+      # group<String>:: The group who should own the server process.
+      #
+      # ==== Alternatives
+      # 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}"
+
+        uid, gid = Process.euid, Process.egid
+        target_uid = Etc.getpwnam(user).uid
+        target_gid = Etc.getgrnam(group).gid
+
+        if uid != target_uid || gid != target_gid
+          # Change process ownership
+          Process.initgroups(user, target_gid)
+          Process::GID.change_privilege(target_gid)
+          Process::UID.change_privilege(target_uid)
+        end
+      rescue Errno::EPERM => e
+        puts "Couldn't change user and group to #{user}:#{group}: #{e}"
+      end
+    end
+  end
+end