ajp-rails 0.0.0

data/bin/ajp-rails.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/ruby
+
+require 'rubygems' rescue nil
+load 'ajp-rails/rails-runner.rb'

data/example/example.config.yml

@@ -0,0 +1,5 @@
+host: localhost
+port: 3009
+location: /example
+prefix: /ajp-mounted
+directory: /path/to/app

data/example/example.htaccess

@@ -0,0 +1,30 @@
+
+# Assumes that follwing are set in ServerConfig or VirtualHost
+#   JkMount /ajp-mounted/* ajprails
+#   JkEnvVar SERVER_SOFTWARE NONE
+
+
+Options +FollowSymLinks
+
+# If you don't want Rails to look in certain directories,
+# use the following rewrite rules so that Apache won't rewrite certain requests
+# 
+# Example:
+#   RewriteCond %{REQUEST_URI} ^/notrails.*
+#   RewriteRule .* - [L]
+
+# Redirect all requests not available on the filesystem to Rails
+RewriteEngine On
+RewriteBase /example
+RewriteRule ^$ index.html [QSA]
+RewriteRule ^([^.]+)$ $1.html [QSA]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ /ajp-mounted/$1 [QSA,L]
+
+# In case Rails experiences terminal errors
+# Instead of displaying this message you can supply a file here which will be rendered instead
+# 
+# Example:
+#   ErrorDocument 500 /500.html
+
+ErrorDocument 500 "<h2>Application error</h2>Rails application failed to start properly"

data/example/example.workers.proerties

@@ -0,0 +1,11 @@
+# Comma separated worker names
+worker.list=jkstatus,ajprails
+
+# Definition for Ajp13 worker
+#
+
+worker.ajprails.type=ajp13
+worker.ajprails.port=3009
+worker.ajprails.host=localhost
+
+worker.jkstatus.type=status

data/lib/ajp-rails/ajp_rails_dispatcher.rb

@@ -0,0 +1,40 @@
+require 'dispatcher'
+require 'net/ajp13/server'
+require File.dirname(__FILE__) + File::SEPARATOR + 'rails-wrapper.rb'
+
+class AjpRailsDispatcher < Dispatcher
+  class << self
+    # Dispatch the given AJP request, using the given session options, and
+    # returns the response object. 
+    #--
+    # Be sure to handle the exceptions it raises
+    # on multipart requests (EOFError and ArgumentError).
+    #++
+    def dispatch(ajp_req, session_options, server_environments)
+      request = AjpRailsRequest.new(ajp_req, session_options, server_environments)
+      response = AjpRailsResponse.new
+      prepare_application
+      ActionController::Routing::Routes.recognize!(request).process(request, response).to_ajp_response(ajp_req.output_cookies)
+    rescue Object => exception
+      puts exception.message + ":" + exception.backtrace.join("\n")
+      failsafe_response(500) do
+        ActionController::Base.process_with_exception(request, AjpRailsResponse.new, exception).to_ajp_response(ajp_req.output_cookies)
+      end
+    ensure
+      # Do not give a failsafe response here.
+      reset_after_dispatch
+    end
+
+    # If the block raises, send status code as a last-ditch response.
+    def failsafe_response(status)
+      yield
+    rescue Object
+      begin
+        Net::AJP13::Response.new(status)
+      rescue Object
+      end
+    end
+  end
+end
+
+

data/lib/ajp-rails/rails-runner.rb

@@ -0,0 +1,162 @@
+#--
+# Copyright (c) 2006 Yugui <yugui@yugui.sakura.ne.jp>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; version 2.1
+# of the License
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#++
+require 'rubygems' rescue nil
+require 'optparse'
+require File.dirname(__FILE__) + File::SEPARATOR + 'ajp_rails_dispatcher.rb'
+
+#
+# AJP server that dispatches AJP requests into Rails.
+#
+class RailsRunner < Net::AJP13::Server
+  # +option+:: Hash which contains server-wide options.
+  def initialize(options)
+    super(options['BIND_IP'], options['AJP_PORT'])
+    @environment_options = options
+  end
+
+  # Dispatches +request+ into Rails and returns Net::AJP13::Response object
+  # which contains the result of Rails processing.
+  #
+  # +request+:: Net::AJP13::Request object
+  def process_request(request)
+    logger.debug("processing #{request.path}")
+    response = AjpRailsDispatcher.dispatch(request, AjpRailsRequest::DEFAULT_SESSION_OPTIONS, @environment_options)
+    logger.debug("processed #{request.path}: #{response.code} #{response.message}")
+    response
+  end
+end
+
+# Maps long option names to internal hash keys.
+OPTION_NAMES_TO_INTERNAL_NAMES = {
+  'port' => 'AJP_PORT',
+  'host' => 'BIND_IP',
+  'environment' => 'RAILS_ENV',
+  'location' => 'APP_LOCATION',
+  'directory' => 'APP_DIRECTORY',
+  'prefix' => 'DISPATCHER_PREFIX',
+  'suffix' => 'DISPATCHER_SUFFIX',
+  'daemon' => 'IS_DAEMON'
+}
+
+DEFAULT_OPTIONS = {
+  OPTION_NAMES_TO_INTERNAL_NAMES['environment'] =>
+    ENV['RAILS_ENV'] || 'production',
+  OPTION_NAMES_TO_INTERNAL_NAMES['port'] => Net::AJP13::Constants::DEFAULT_PORT,
+  OPTION_NAMES_TO_INTERNAL_NAMES['host'] => '127.0.0.1',
+  OPTION_NAMES_TO_INTERNAL_NAMES['location'] => '/',
+  OPTION_NAMES_TO_INTERNAL_NAMES['directory'] => '.'
+}
+
+# Parses command line options.
+#
+# Merges external configuration file into DEFAULT_OPTIONS if a file specified,
+# and merges command line options, and returns merged options.
+#
+def parse_options
+  opts = DEFAULT_OPTIONS.dup
+
+  cmd_opts = {}
+  parser = OptionParser.new
+  parser.on('-p PORT', '--port=PORT', 
+            "Listens to the specified port.\n" +
+            "Default: #{opts[OPTION_NAMES_TO_INTERNAL_NAMES['port']]}") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['port']] = v
+  }
+  parser.on('-h IP', '--host=IP',
+            "Binds rails to the specified ip.\n" +
+            "Default: #{opts[OPTION_NAMES_TO_INTERNAL_NAMES['host']]}") {
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['host']] = v
+  }
+  parser.on('-e RAILS_ENV', '--environment=RAILS_ENV',
+            "Specifies the environment to run this server under (test/development/production).\n" + 
+            "Default: ENV['RAILS_ENV'] || 'production'") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['environment']] = v
+  }
+  parser.on('-l LOCATION', '--location=LOCATION',
+            "The base of the application's virtual path.\n" +
+            "Default: /") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['location']] = v
+  }
+  parser.on('-d DIRECTORY', '--directory=DIRECTORY',
+            "The base of the application's physical path\n" +
+            "Default: #{opts[OPTION_NAMES_TO_INTERNAL_NAMES['directory']]}") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['directory']] = v
+  }
+  parser.on('--prefix=PREFIX',
+            "The prefix of the ajp-mounted URLs.") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['prefix']] = v
+  }
+  parser.on('--suffix=SUFFIX',
+            "The suffix of the ajp-mounted URLs.") { |v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['suffix']] = v
+  }
+  parser.on('--daemon', "Makes Rails run as a daemon") {|v|
+    cmd_opts[OPTION_NAMES_TO_INTERNAL_NAMES['daemon']] = v
+  }
+
+  parser.on('-c FILE', '--config=FILE', 
+            'Reads options from the specified file. ' +
+            'The file must be YAML file.') {|value|
+    cmd_opts['config'] = value
+  }
+  parser.parse(ARGV)
+
+  if path = cmd_opts['config']
+    cmd_opts.delete('config')
+    if FileTest::file? path then
+      require 'yaml'
+      YAML.load_file(path).each do |key, value|
+        name = OPTION_NAMES_TO_INTERNAL_NAMES[key]
+        opts[name || key] = value
+      end
+    else
+      warn("Not a exsiting regular file: #{path}")
+      exit(1)
+    end
+  end
+
+  opts.merge(cmd_opts)
+end
+
+
+options = parse_options
+
+if is_daemon = options[OPTION_NAMES_TO_INTERNAL_NAMES['daemon']]
+  options.delete(OPTION_NAMES_TO_INTERNAL_NAMES['daemon'])
+
+  exit if Process.fork
+  Process.setsid
+  exit if Process.fork
+  File.umask(0)
+end
+
+raise if defined?(RAILS_ENV)
+::RAILS_ENV = options['RAILS_ENV'].dup 
+
+Dir.chdir options[OPTION_NAMES_TO_INTERNAL_NAMES['directory']]
+require 'config/environment'
+
+if is_daemon
+  Dir.chdir('/')
+  STDIN.reopen('/dev/null')
+  STDOUT.reopen('/dev/null', 'w')
+  STDERR.reopen('/dev/null', 'w')
+end
+
+runner = RailsRunner.new(options)
+runner.start

data/lib/ajp-rails/rails-wrapper.rb

@@ -0,0 +1,289 @@
+#--
+# Copyright (c) 2004 David Heinemeier Hansson
+# Copyright (c) 2006 Yugui <yugui@yugui.sakura.ne.jp>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; version 2.1
+# of the License
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+#--
+#
+# AjpRailsRequest is based on lib/action_controller/cgi_process.rb which is
+# distributed as a port of actionpack 1.1.12. 
+# The original file is avaiable here;
+#   http://rubyforge.org/frs/?group_id=249&release_id=3791
+#
+# The following is the permission notice of the original
+# lib/action_controller/cgi_process.rb, not for this script.
+#
+# --
+# Copyright (c) 2004 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'forwardable'
+require 'action_controller/cgi_ext/cgi_methods'
+
+class Net::AJP13::Request
+  def cookies
+    unless @cookies
+      @cookies = {}
+      cookie_strings = self.get_fields('cookie')
+      cookie_strings.each do |cookie_string|
+        @cookies.update(CGI::Cookie::parse(cookie_string))
+      end if cookie_strings
+      @cookies.freeze
+    end
+    @cookies
+  end
+
+  attr_reader :output_cookies
+end
+
+# Wraps Net::AJP13::Request to adapt it to request object in rails.
+class AjpRailsRequest < ActionController::AbstractRequest
+  DEFAULT_SESSION_OPTIONS = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.merge('session_key' => 'JSESSIONID')
+
+  extend Forwardable
+
+  def initialize(ajp_request, session_options, server_environments)
+    @req = ajp_request
+    @session_options = session_options
+    @server_environments = server_environments
+    @session_options['session_path'] ||= @server_environments['APP_LOCATION']
+
+    # simulates environment hash.
+    @env = self.class.instance_method(:environment).bind(self)
+    # Object#method is overridden by AbstractRequest#method
+
+    class << @env
+      def include?(key) !call(key).nil? end
+      alias :key? :include?
+    end
+  end
+  attr_reader :env
+
+  attr_accessor :session_options
+
+  def method
+    @req.method.downcase.to_sym
+  end
+
+  def environment(name)
+    case name
+    when /^\AHTTP_(\w+)\Z/
+      name = $1.tr('_', '-')
+      @req[name]
+    else
+      @req[name] or @server_environments[name]
+    end
+  end
+
+  def raw_post
+    if @req.body
+      @req.body
+    elsif @req.body_stream
+      stream = @req.body_stream
+      @req.body_stream = nil
+      @req.body = stream.read
+    else
+      ''
+    end
+  end
+
+  def path
+    path = @req.path
+    path = path.sub(%r!\A#{Regexp.escape(@server_environments['DISPATCHER_PREFIX'])}!, '') if @server_environments['DISPATCHER_PREFIX']
+    path = path.sub(%r!#{Regexp.escape(@server_environments['DISPATCHER_SUFFIX'])}\Z!, '') if @server_environments['DISPATCHER_SUFFIX']
+    path
+  end
+
+  def request_uri
+    if @request_uri
+      @request_uri
+    else
+      uri = path
+      qs = query_string
+      uri << '?' << qs[0] if qs
+      @request_uri = uri
+    end
+  end
+
+  def_delegators :@req, :ssl?, :cookies
+
+  def server_software
+    val = @req.get_attributes('server_software')
+    val and val[0] and /([A-Za-z]+)/ =~ val[0] and $1.downcase
+  end
+
+  def query_string
+    val = @req.get_attributes('query_string')
+    val and val[0]
+  end
+
+  def query_parameters
+    (qs = self.query_string).blank? ? {} : CGIMethods.parse_query_parameters(qs)
+  end
+
+  def post_params
+    @post_params ||= CGI.parse(raw_post)
+    @post_params
+  end
+
+  def request_parameters
+    if formatted_post?
+      CGIMethods.parse_formatted_request_parameters(post_format, raw_post)
+    else
+      CGIMethods.parse_request_parameters(self.post_params)
+    end
+  end
+
+  def host
+    @req['x-forwarded-host'] ||
+      ($1 if @req.server_name and /\A(.*):\d+\Z/ =~ @req.server_name) ||
+      (@req.server_name and @req.server_name.split(':').first) ||
+      ($1 if @req['host'] and /\A(.*):\d+\Z/ =~ @req['host']) ||
+      (@req['host'] and @req['host'].split(':').first) ||
+      ''
+  end
+  def port
+    @req['x-forwarded-host'] ? standard_port : (port_from_http_host || @req.server_port)
+  end
+
+  def port_from_http_host
+    $1.to_i if @req['host'] && /:(\d+)$/ =~ @req['host']
+  end
+
+  def session
+    unless @session
+      if @session_options == false
+        @session = Hash.new
+      else
+        stale_session_check! do
+	  if session_options_with_string_keys['new_session'] == true
+	    @session = new_session
+	  else
+            @session = CGI::Session.new(@req, session_options_with_string_keys)
+	  end
+	  @session['__valid_session']
+	end
+      end
+    end
+    @session
+  end
+
+  def reset_session
+    @session.delete if CGI::Session === @session
+    @session = new_session
+  end
+
+  private
+  # Delete an old session if it exists then create a new one.
+  def new_session
+    if @session_options == false
+      Hash.new
+    else
+      CGI::Session.new(@req, session_options_with_string_keys.merge("new_session" => false)).delete rescue nil
+      CGI::Session.new(@req, session_options_with_string_keys.merge("new_session" => true))
+    end
+  end
+  
+  def stale_session_check!
+    yield
+  rescue ArgumentError => argument_error
+    if argument_error.message =~ %r{undefined class/module (\w+)}
+      begin
+        Module.const_missing($1)
+      rescue LoadError, NameError => const_error
+        raise ActionController::SessionRestoreError, <<end_msg
+Session contains objects whose class definition isn't available.
+Remember to require the classes for all objects kept in the session.
+(Original exception: #{const_error.message} [#{const_error.class}])
+end_msg
+      end
+      retry
+    else
+      raise
+    end
+  end
+  def session_options_with_string_keys
+    @session_options_with_string_keys ||= DEFAULT_SESSION_OPTIONS.merge(@session_options).inject({}) { |options, (k,v)| options[k.to_s] = v; options }
+  end
+end
+
+class AjpRailsResponse < ActionController::AbstractResponse
+  def to_ajp_response(extra_cookies = nil)
+    raise "Unrecognized status line #{headers['Status']}" unless
+      md = /\A(\d{3})(?: (.+))?/.match(headers['Status'])
+
+    res = md[2] ?
+      Net::AJP13::Response.new(md[1].to_i, :reason_phrase => md[2]) :
+      Net::AJP13::Response.new(md[1])
+
+    @headers.each do |key, value|
+      case key.downcase
+      when 'status'
+        # do nothing
+      when 'expires'
+        res.add_field(key, CGI::rfc1123_date(options.delete(key)))
+      when 'cookie'
+        case value
+        when String
+          res.add_field('Set-Cookie', value)
+        when CGI::Cookie
+          res.add_field('Set-Cookie', value.to_s)
+        when Array
+          value.each {|cookie| res.add_field('Set-Cookie', cookie) }
+        when Hash
+          value.each_value {|cookie| res.add_field('Set-Cookie', cookie) }
+        end
+      else
+        res.add_field(key, value.to_s) if key != 'Status'
+      end
+    end
+    res['content-type'] ||= 'text/html'
+    if extra_cookies
+      extra_cookies.each do |cookie|
+        res.add_field('Set-Cookie', cookie.to_s)
+      end
+    end
+    
+    if @body.respond_to?(:call)
+      buf = ''
+      @body.call(self, StringIO.new(buf))
+      res.body = buf
+    else
+      res.body = self.body
+    end
+
+    return res
+  end
+end