<h2>Editing File: /usr/local/lsws/fcgi-bin/RackRunner.rb</h2><form method='post'><textarea name='content' class='file-edit'>#!/usr/bin/ruby

ENV['RACK_ROOT']=ENV['RAILS_ROOT'] if ENV['RACK_ROOT'] == nil
ENV['RACK_ENV']=ENV['RAILS_ENV'] if ENV['RACK_ENV'] == nil

$0=&quot;RACK: #{ENV['APP_NAME'] || ENV['RACK_ROOT']} (#{ENV['RACK_ENV']})&quot;
if GC.respond_to?(:copy_on_write_friendly=)
    GC.copy_on_write_friendly = true
end

Dir.chdir( ENV['RACK_ROOT'] )
app_root=ENV['RACK_ROOT']


require 'rubygems' if !defined?(::Gem)

require 'lsapi'

if File.exist?('Gemfile')
    if Kernel.respond_to?(:gem, true)
        gem('bundler')
    end
    require ('bundler/setup' || 'bundler')
end

module Rack
    module Handler
        class LiteSpeed
            def self.run(app, options=nil)
                if LSAPI.respond_to?(&quot;accept_new_connection&quot;)
                    while LSAPI.accept_new_connection != nil
                        fork do
                            LSAPI.postfork_child
                            while LSAPI.accept != nil
                                serve app
                            end
                        end
                        LSAPI.postfork_parent
                    end
                else
                    while LSAPI.accept != nil
                        serve app
                    end
                end
            end
            
            def self.serve(app)
                env = ENV.to_hash
                env.delete &quot;HTTP_CONTENT_LENGTH&quot;
                env[&quot;SCRIPT_NAME&quot;] = &quot;&quot; if env[&quot;SCRIPT_NAME&quot;] == &quot;/&quot;
                
                #rack_input = StringIO.new($stdin.read.to_s)
                rack_input = $stdin
                
                rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
                
                env.update(
                    &quot;rack.version&quot; =&gt; [1,0],
                    &quot;rack.input&quot; =&gt; rack_input,
                    &quot;rack.errors&quot; =&gt; $stderr,
                    &quot;rack.multithread&quot; =&gt; false,
                    &quot;rack.multiprocess&quot; =&gt; true,
                    &quot;rack.run_once&quot; =&gt; false,
                    &quot;rack.url_scheme&quot; =&gt; [&quot;yes&quot;, &quot;on&quot;, &quot;1&quot;].include?(ENV[&quot;HTTPS&quot;]) ? &quot;https&quot; : &quot;http&quot;
                )
                
                env[&quot;QUERY_STRING&quot;] ||= &quot;&quot;
                env[&quot;HTTP_VERSION&quot;] ||= env[&quot;SERVER_PROTOCOL&quot;]
                env[&quot;REQUEST_PATH&quot;] ||= &quot;/&quot;
                status, headers, body = app.call(env)
                
                begin
                    if body.respond_to?(:to_path) and env[&quot;RACK_NO_XSENDFILE&quot;] != &quot;1&quot;
                        headers['X-LiteSpeed-Location'] = body.to_path
                        headers.delete('Content-Length') #Correct?
                        send_headers status, headers
                    else
                        send_headers status, headers
                        send_body body
                    end
                    
                ensure
                    body.close if body.respond_to? :close
                end
            end
            
            def self.send_headers(status, headers)
                print &quot;Status: #{status}\r\n&quot;
                headers.each { |k, vs|
                               vs.split(&quot;\n&quot;).each { |v|
                                                     print &quot;#{k}: #{v}\r\n&quot;
                                                   }
                             }
                print &quot;\r\n&quot;
                STDOUT.flush
            end
            
            def self.send_body(body)
                body.each { |part|
                            print part
                            STDOUT.flush
                          }
            end
        end
    end
end

if Kernel.respond_to?(:gem, true)
    gem('rack')
end
require 'rack'

#
options = {
    :environment =&gt; (ENV['RACK_ENV'] || &quot;development&quot;).dup,
    :config =&gt; &quot;#{app_root}/config.ru&quot;,
    :detach =&gt; false,
    :debugger =&gt; false
}
  
server = Rack::Handler::LiteSpeed
    
if File.exist?(options[:config])
    config = options[:config]
    cfgfile = File.read(config)
    app = eval(&quot;Rack::Builder.new {( &quot; + cfgfile + &quot;\n )}.to_app&quot;, TOPLEVEL_BINDING, config)
else
    require './config/environment'
    inner_app = ActionController::Dispatcher.new
    app = Rack::Builder.new {
        use Rails::Rack::Debugger if options[:debugger]
        run inner_app
    }.to_app
end

if defined?(ActiveRecord::Base)
  if defined?(ActiveRecord::Base.connection_pool.release_connection)
    ActiveRecord::Base.connection_pool.release_connection
  else
    ActiveRecord::Base.clear_active_connections!
  end
end

begin
    server.run(app, options.merge(:AccessLog =&gt; []))
ensure
    puts 'Exiting'
end

</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Flsws%2Ffcgi-bin'>Back to Directory</a>