require 'rubygems'
require 'socket'
begin
        require 'bundler/setup'
rescue LoadError
end
require 'rack'
require 'rack/content_length'
require 'rack/rewindable_input'
require 'stringio'

require 'optparse'

options = {
        :processes => 1,
        :threads => 1,
        :master => false,
        :logging => true,
        :static => true,
        :config => nil,
        :cachehack => false
}

opts = OptionParser.new do |opts|

        opts.on("-p", "--processes=nproc", Integer, '') { |p| options[:processes] = p }
        opts.on("-t", "--threads=nthreads", Integer, '') { |t| options[:threads] = t }
        opts.on("-M", "--master", '') { options[:master] = true }
        opts.on("-L", "--no-logging", '') { options[:logging] = false }
        opts.on("-S", "--no-static", '') { options[:static] = false }
        opts.on("-C", "--cache-hack", '') { options[:cachehack] = true }
        
        opts.parse! ARGV
end

if ARGV[0]
        options[:config] = ARGV[0]
end

def human_round(float)
        (float * (10 ** 2)).round / (10 ** 2).to_f
end

$requests = 0
$workers = Array.new
$mywid = 0

module Rack

  class RailsCachingHack
    def initialize app
      @app = app
    end

    def stripuri(uri)
      uri = uri.split('/')
      uri.slice!(1)
      val = uri.join('/')
    end
    def call env
      env['PATH_INFO'] = stripuri(env['PATH_INFO']) if env['PATH_INFO']
      env['REQUEST_URI'] = stripuri(env['REQUEST_URI']) if env['REQUEST_URI']
      env['REQUEST_URI'] = '/' if env['REQUEST_URI'] == ''
      @app.call env
    end
  end

  module Handler
    class Unbit

      def self.run(app, options={})
        server = UNIXServer.for_fd(0)

        can_spawn = true
        if options[:master]
                $0 = 'uRack master'
                $workers[0] = Process.pid
                ulog("master process enabled (pid: #{$workers[0]})")
                $workers[1] = Process.fork
                if $workers[1].to_i > 0
                        ulog("spawned worker 1 (pid: #{$workers[1]})")
                elsif $workers[1].to_i == 0
                        $0 = "uRack worker 1"
			$mywid = 1
                        can_spawn = false
                end
        else
                $0 = 'uRack worker 1'
                $workers[0] = nil
                $workers[1] = Process.pid
		$mywid = 1
                ulog("spawned worker 1 (pid: #{$workers[1]})")
        end

        if options[:processes] > 1 and can_spawn
                for p in 2..options[:processes]
                        $workers[p] = Process.fork
                        if $workers[p].to_i == 0
                                $0 = "uRack worker #{p}"
				$mywid = p
                                break
                        elsif $workers[p].to_i > 0
                                ulog("spawned worker #{p} (pid: #{$workers[p]})")
                        end
                end
        end

        # am i the master ?
        if options[:master] and Process.pid == $workers[0]
                while 1
                        i_am_a_child = false
                        pid = Process.waitpid
                        for wid in 1..options[:processes]
                                if $workers[wid] == pid
                                        ulog("worker #{wid} died ! (pid: #{pid})")
                                        $workers[wid] = Process.fork
                                        if $workers[wid].to_i == 0
                                                $0 = "uRack worker #{wid}"
                                                i_am_a_child = true
						$mywid = wid
                                                break
                                        elsif $workers[wid].to_i > 0
                                                ulog("respawned worker #{wid} (pid: #{$workers[wid]})")
                                        end
                                        
                                end
                        end
                        break if i_am_a_child
                end
        end
        
	if options[:threads] > 2
		for t in 2..options[:threads]
			wt = Thread.new do
			    ulog("spawning thread #{t} on worker #{$mywid}")
            		    while client = server.accept
                		serve client, app, options
            		    end
			end
		end
	end

        while client = server.accept
        	serve client, app, options
        end

      end

      def self.serve(client, app, options)

        speed = Time.now
        head, sender = client.recvfrom(4)

        unless head
          client.close
          return
        end
        
        mod1, size, mod2 = head.unpack('CvC')

        if size == 0 or size.nil?
          client.close
          return
        end

        vars, sender = client.recvfrom(size)

        if vars.length != size
          client.close
          return
        end

        env = Hash.new

        i = 0
        while i < size
          kl = vars[i, 2].unpack('v')[0]
          i = i + 2
          key = vars[i, kl]
          i = i + kl
          vl = vars[i, 2].unpack('v')[0]
          i = i + 2
          value = vars[i, vl]
          i = i + vl
          env[key] = value
        end



        env.delete "HTTP_CONTENT_LENGTH"
        env.delete "HTTP_CONTENT_TYPE"

        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
        env["QUERY_STRING"] ||= ""
        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
        env["REQUEST_PATH"] ||= "/"
        env.delete "PATH_INFO"  if env["PATH_INFO"] == ""
        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
        
        
        if env["CONTENT_LENGTH"].to_i > 4096
                rack_input = Rack::RewindableInput::Tempfile.new('Rack_unbit_Input')
                rack_input.chmod(0000)
                rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
                rack_input.binmode
                rack_input.unlink

                remains = env["CONTENT_LENGTH"].to_i
                while remains > 0
                        if remains >= 4096
                                buf, sender = client.recvfrom(4096)
                        else
                                buf, sender = client.recvfrom(remains)
                        end

			if buf.length == 0
				break
			end

                        rack_input.write( buf )
                        remains -= buf.length
                end

        elsif env["CONTENT_LENGTH"].to_i > 0
                rack_input =  StringIO.new(client.recvfrom(env["CONTENT_LENGTH"].to_i)[0])
        else
                rack_input = StringIO.new('')
        end

        rack_input.rewind

        env.update({"rack.version" => [1,1],
                     "rack.input" => rack_input,
                     "rack.errors" => $stderr,

                     "rack.multithread" => false,
                     "rack.multiprocess" => true,
                     "rack.run_once" => false,

                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
                   })

        app = Rack::ContentLength.new(app)

        disconnected = false
        begin
          status, headers, body = app.call(env)
          begin
            send_headers client, env["HTTP_VERSION"] ,status, headers
            send_body client, body
          ensure
            body.close  if body.respond_to? :close
          end
        rescue Errno::EPIPE, Errno::ECONNRESET
          disconnected = true
        ensure
          rack_input.close
          client.close
        end
        $requests = $requests+1
        
        ulog("req: #{$requests} ip: #{env['REMOTE_ADDR']} pid: #{Process.pid} as: #{human_round(syscall(356).to_f/1024/1024)} MB => #{env['REQUEST_METHOD']} #{env['REQUEST_URI']} in #{Time.now-speed} secs [#{status}]#{' DISCONNECTED !!!' if disconnected}") if options[:logging]
      end

      def self.send_headers(client, protocol, status, headers)
        client.print "#{protocol} #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}\r\n"
        headers.each { |k, vs|
          vs.split("\n").each { |v|
            client.print "#{k}: #{v}\r\n"
          }
        }
        client.print "\r\n"
        client.flush
      end

      def self.send_body(client, body)
        body.each { |part|
          client.print part
          client.flush
        }
      end
    end
  end
end

def ulog(message)
        $stderr.puts "[#{Time.new}] uRack: #{message}"
end

ulog("starting at #{Dir.getwd}")
limit_as = human_round(Process.getrlimit(Process::RLIMIT_AS)[1].to_f/1024/1024)
ulog("your process address space limit is #{limit_as} MB")
server = Rack::Handler.get('Unbit')

starttime = Time.now

app = nil

if options[:config]
        cfgfile = File.read(options[:config])
        if cfgfile[/^#\\(.*)/]
                opts.parse! $1.split(/\s+/)
        end
        app = eval "Rack::Builder.new {( " + cfgfile + "\n )}.to_app", nil, options[:config]
else
        # falling back to rails
        if Dir.getwd =~ /\/public\/?$/  
                require '../config/environment'
        else
                require 'config/environment'
        end
        app = Rack::Builder.new {
                if options[:cachehack]
                        use Rack::RailsCachingHack
                end
                if options[:static]
                        use Rails::Rack::Static
                end
                if ActionController.const_defined?(:Dispatcher) && (ActionController::Dispatcher.instance_methods.include?(:call) || ActionController::Dispatcher.instance_methods.include?("call"))
                        run ActionController::Dispatcher.new
                else
                        require 'thin'
                        run Rack::Adapter::Rails.new(:environment => ENV['RAILS_ENV'])
                end
        }
end


ulog("your app is ready (in #{Time.now-starttime} seconds).")


server.run(app, options)