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

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

Dir.chdir( ENV['RAILS_ROOT'] )
require 'rails/version'
require './config/boot'

if defined? Rails::VERSION
    rails_ver = Rails::VERSION::STRING
elsif defined? RAILS_GEM_VERSION
    rails_ver = RAILS_GEM_VERSION
elsif ENV.include?('RAILS_GEM_VERSION')
    rails_ver = ENV['RAILS_GEM_VERSION']
else
    environmentrb = File.read('config/environment.rb')
    rails_ver = $1 if environmentrb =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*[&quot;']([!~&lt;&gt;=]*\s*[\d.]+)[&quot;']/
end
app_root=ENV['RAILS_ROOT']
if rails_ver != nil and rails_ver &gt;= '2.3.0'
    #use rack
    require 'active_support'
    require 'action_controller'
    require 'fileutils'

    require 'rack/content_length'
    require 'lsapi'

    module Rack
      module Handler
        class LiteSpeed
          def self.run(app, options=nil)
            while LSAPI.accept != nil
                serve app
            end
          end
          def self.serve(app)
            app = Rack::ContentLength.new(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)

            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
              send_headers status, headers
              send_body body
            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
    
    options = {
        :environment =&gt; (ENV['RAILS_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]
    if config =~ /\.ru$/
        cfgfile = File.read(config)
        if cfgfile[/^#\\(.*)/]
            opts.parse!($1.split(/\s+/))
        end
        inner_app = eval(&quot;Rack::Builder.new {( &quot; + cfgfile + &quot;\n )}.to_app&quot;, nil, config)
    else
        require config
        inner_app = Object.const_get(File.basename(config, '.rb').capitalize)
    end
    else
        require './config/environment'
        inner_app = ActionController::Dispatcher.new
    end
    
    app = Rack::Builder.new {
        use Rails::Rack::Debugger if options[:debugger]
        run inner_app
    }.to_app

    ActiveRecord::Base.clear_all_connections! if defined?(ActiveRecord::Base)

    begin
        server.run(app, options.merge(:AccessLog =&gt; []))
    ensure
        puts 'Exiting'
    end
 
else
  
    require './config/environment'
    
    require 'initializer'
    require 'dispatcher'
    
    #require 'breakpoint' if defined?(BREAKPOINT_SERVER_PORT)

    #if RAILS_ENV=='production'
    #   require_dependency 'application'
    #   Dir.foreach( &quot;app/models&quot; ) {|f| silence_warnings{require_dependency f} if f =~ /\.rb$/}
    #   Dir.foreach( &quot;app/controllers&quot; ) {|f|  silence_warnings{require_dependency f} if f =~ /\.rb$/}
    #end

    require 'lsapi'

    #Close all DB connections established during initialization
    if defined?(ActiveRecord::Base)
    if defined?(ActiveRecord::Base.clear_active_connections!)
        ActiveRecord::Base.clear_active_connections!
    else
        ActiveRecord::Base.connection.disconnect!
        @reconnect = true
        ActiveRecord::Base.establish_connection
    end
    end

    while LSAPI.accept != nil
        if defined?(ActiveRecord::Base) and @reconnect
            ActiveRecord::Base.connection.reconnect!
            @reconnect = false
        end

        Dispatcher.dispatch
    end
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>