merb-core 0.9.2

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/server.rb

@@ -0,0 +1,184 @@
+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|
+            unless alive?(port)
+              remove_pid_file(port)
+              puts "Starting merb server on port: #{port}"
+              daemonize(port)
+            else
+              raise "Merb is already running on port: #{port}"
+            end
+          end   
+        elsif Merb::Config[:daemonize]
+          unless alive?(@port)  
+            remove_pid_file(@port)
+            daemonize(@port)
+          else
+            raise "Merb is already running on port: #{port}"
+          end
+        else
+          trap('TERM') { exit }
+          BootLoader.run
+          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)
+        f = "#{Merb.log_path}" / "merb.#{port}.pid"
+        pid = IO.read(f).chomp.to_i
+        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
+          Dir[Merb.log_path/ "merb.#{port == 'all' ? '*' : port }.pid"].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)
+        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
+          if Merb::Config[:user]
+            if Merb::Config[:group]
+              change_privilege(Merb::Config[:user], Merb::Config[:group])
+            else
+              change_privilege(Merb::Config[:user])
+            end    
+          end  
+          BootLoader.run
+          Merb.adapter.start(Merb::Config.to_hash)
+        end
+      end
+
+      # Removes a PID file from the filesystem.
+      #
+      # ==== 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)
+        if Merb::Config[:pid_file]
+          pidfile = Merb::Config[:pid_file]
+        else
+          pidfile = Merb.log_path / "merb.#{port}.pid"
+        end
+        FileUtils.rm(pidfile) if File.exist?(pidfile)
+      end
+
+      # Stores a PID file on the filesystem.
+      #
+      # ==== 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)
+        FileUtils.mkdir_p(Merb.log_path) unless File.directory?(Merb.log_path)
+        if Merb::Config[:pid_file]
+          pidfile = Merb::Config[:pid_file]
+        else
+          pidfile = Merb.log_path / "merb.#{port}.pid"
+        end
+        File.open(pidfile, 'w'){ |f| f.write("#{Process.pid}") }
+      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

data/lib/merb-core/test.rb

@@ -0,0 +1,10 @@
+require "hpricot"
+
+require 'merb-core/test/test_ext/hpricot'
+require 'merb-core/test/test_ext/object'
+
+module Merb; module Test; end; end
+
+require 'merb-core/test/helpers'
+
+require 'merb-core/test/matchers'

data/lib/merb-core/test/helpers.rb

@@ -0,0 +1,9 @@
+# This is a place holder to allow plugins etc a place to include 
+# testing helpers
+module Merb::Test::Helpers; end
+
+require "merb-core/test/helpers/request_helper"
+require "merb-core/test/helpers/multipart_request_helper"
+require "merb-core/test/helpers/controller_helper"
+require "merb-core/test/helpers/route_helper"
+require "merb-core/test/helpers/view_helper"

data/lib/merb-core/test/helpers/controller_helper.rb

@@ -0,0 +1,8 @@
+module Merb
+  module Test
+    module ControllerHelper
+      include RequestHelper
+      include MultipartRequestHelper
+    end
+  end
+end

data/lib/merb-core/test/helpers/multipart_request_helper.rb

@@ -0,0 +1,175 @@
+module Merb::Test::MultipartRequestHelper
+  require 'rubygems'
+  require 'mime/types'
+
+  class Param
+    attr_accessor :key, :value
+
+    # ==== Parameters
+    # key<~to_s>:: The parameter key.
+    # value<~to_s>:: The parameter value.
+    def initialize(key, value)
+      @key   = key
+      @value = value
+    end
+
+    # ==== Returns
+    # String:: The parameter in a form suitable for a multipart request.
+    def to_multipart
+      return %(Content-Disposition: form-data; name="#{key}"\r\n\r\n#{value}\r\n)
+    end
+  end
+
+  class FileParam
+    attr_accessor :key, :filename, :content
+
+    # ==== Parameters
+    # key<~to_s>:: The parameter key.
+    # filename<~to_s>:: Name of the file for this parameter.
+    # content<~to_s>:: Content of the file for this parameter.
+    def initialize(key, filename, content)
+      @key      = key
+      @filename = filename
+      @content  = content
+    end
+
+    # ==== Returns
+    # String::
+    #   The file parameter in a form suitable for a multipart request.
+    def to_multipart
+      return %(Content-Disposition: form-data; name="#{key}"; filename="#{filename}"\r\n) + "Content-Type: #{MIME::Types.type_for(@filename)}\r\n\r\n" + content + "\r\n"
+    end
+  end
+
+  class Post
+    BOUNDARY = '----------0xKhTmLbOuNdArY'
+    CONTENT_TYPE = "multipart/form-data, boundary=" + BOUNDARY
+
+    # ==== Parameters
+    # params<Hash>:: Optional params for the controller.
+    def initialize(params = {})
+      @multipart_params = []
+      push_params(params)
+    end
+
+    # Saves the params in an array of multipart params as Param and
+    # FileParam objects.
+    #
+    # ==== Parameters
+    # params<Hash>:: The params to add to the multipart params.
+    # prefix<~to_s>:: An optional prefix for the request string keys.
+    def push_params(params, prefix = nil)
+      params.sort_by {|k| k.to_s}.each do |key, value|
+        param_key = prefix.nil? ? key : "#{prefix}[#{key}]"
+        if value.respond_to?(:read)
+          @multipart_params << FileParam.new(param_key, value.path, value.read)
+        else
+          if value.is_a?(Hash) || value.is_a?(Mash)
+            value.keys.each do |k|
+              push_params(value, param_key)
+            end
+          else
+            @multipart_params << Param.new(param_key, value)
+          end
+        end
+      end
+    end
+
+    # ==== Returns
+    # Array[String, String]:: The query and the content type.
+    def to_multipart
+      query = @multipart_params.collect { |param| "--" + BOUNDARY + "\r\n" + param.to_multipart }.join("") + "--" + BOUNDARY + "--"
+      return query, CONTENT_TYPE
+    end
+  end 
+
+  # Similar to dispatch_to but allows for sending files inside params.  
+  #
+  # ==== Paramters 
+  # controller_klass<Controller>::
+  #   The controller class object that the action should be dispatched to.
+  # action<Symbol>:: The action name, as a symbol.
+  # params<Hash>::
+  #   An optional hash that will end up as params in the controller instance.
+  # env<Hash>::
+  #   An optional hash that is passed to the fake request. Any request options
+  #   should go here (see +fake_request+).
+  # &blk:: The block is executed in the context of the controller.
+  #  
+  # ==== Example
+  #   dispatch_multipart_to(MyController, :create, :my_file => @a_file ) do
+  #     self.stub!(:current_user).and_return(@user)
+  #   end
+  #
+  # ==== Note
+  # Set your option to contain a file object to simulate file uploads.
+  #   
+  # Does not use routes.
+  #---
+  # @public
+  def dispatch_multipart_to(controller_klass, action, params = {}, env = {}, &blk)
+    request = multipart_fake_request(env, params)
+    dispatch_request(request, controller_klass, action, &blk)
+  end
+
+  # An HTTP POST request that operates through the router and uses multipart
+  # parameters.
+  #
+  # ==== Parameters
+  # path<String>:: The path that should go to the router as the request uri.
+  # params<Hash>::
+  #   An optional hash that will end up as params in the controller instance.
+  # env<Hash>::
+  #   An optional hash that is passed to the fake request. Any request options
+  #   should go here (see +fake_request+).
+  # block<Proc>:: The block is executed in the context of the controller.
+  #
+  # ==== Note
+  # To include an uploaded file, put a file object as a value in params.
+  def multipart_post(path, params = {}, env = {}, &block)
+    env[:request_method] = "POST"
+    env[:test_with_multipart] = true
+    request(path, params, env, &block)
+  end
+
+  # An HTTP PUT request that operates through the router and uses multipart
+  # parameters.
+  #
+  # ==== Parameters
+  # path<String>:: The path that should go to the router as the request uri.
+  # params<Hash>::
+  #   An optional hash that will end up as params in the controller instance.
+  # env<Hash>::
+  #   An optional hash that is passed to the fake request. Any request options
+  #   should go here (see +fake_request+).
+  # block<Proc>:: The block is executed in the context of the controller.
+  #
+  # ==== Note
+  # To include an uplaoded file, put a file object as a value in params.
+  def multipart_put(path, params = {}, env = {}, &block)
+    env[:request_method] = "PUT"
+    env[:test_with_multipart] = true
+    request(path, params, env, &block)
+  end
+  
+  # ==== Parameters
+  # env<Hash>::
+  #   An optional hash that is passed to the fake request. Any request options
+  #   should go here (see +fake_request+).
+  # params<Hash>::
+  #   An optional hash that will end up as params in the controller instance.
+  # 
+  # ==== Returns
+  # FakeRequest::
+  #   A multipart Request object that is built based on the parameters.
+  def multipart_fake_request(env = {}, params = {})
+    if params.empty?
+      fake_request(env)
+    else
+      m = Post.new(params)
+      body, head = m.to_multipart
+      fake_request(env.merge( :content_type => head, 
+                              :content_length => body.length), :post_body => body)
+    end
+  end
+end