kirk 0.1.0-java

data/README.md

@@ -0,0 +1,102 @@
+# Kirk: a JRuby Rack server based on Jetty
+
+Kirk is a wrapper around Jetty that hides all of the insanity and wraps your
+Rack application in a loving embrace. Also, Kirk is probably the least HTTP
+retarded ruby rack server out there.
+
+### TL;DR
+
+    gem install kirk
+    rackup -s Kirk config.ru
+
+### Features
+
+Here is a brief highlight of some of the features available.
+
+* 0 Downtime deploys: Deploy new versions of your rack application without
+  losing a single request. The basic strategy is similar to Passenger.
+  Touch a magic file in the application root and Kirk will reload the
+  application without dropping a single request... It's just magic.
+
+* Request body streaming: Have a large request body to handle? Why wait until
+  receiving the entire thing before starting the work?
+
+* HTTP goodness: `Transfer-Encoding: chunked`, `Content-Encoding: gzip` (and
+  deflate) support on the request.
+
+* Concurrency: As it turns out, it's nice to not block your entire application
+  while waiting for an HTTP request to finish. It's also nice to be able to
+  handle more than 50 concurrent requests without burning over 5GB of RAM. Sure,
+  RAM is cheap, but using Kirk is cheaper ;)
+
+* Run on the JVM: I, for one, am a fan of having a predictable GC, a JIT
+  compiler, and other goodness.
+
+### Getting Started
+
+To take advantage of the zero downtime redeploy features, you will need to
+create a configuration file that describes to Kirk how to start and watch the
+rack application. You can create the file anywhere. For example, let's say that
+we are going to put the following configuration file at `/path/to/Kirkfile`.
+
+    # Set the log level to ALL.
+    log :level => :all
+
+    rack "/path/to/my/rackup/config.ru" do
+      # Set the host and / or port that this rack application will
+      # be available on. This defaults to "0.0.0.0:9090"
+      listen 80
+
+      # Set the host names that this rack application wll be available
+      # on. This defaults to "*"
+      hosts "example.com", "*.example.org"
+
+      # Set the file that controls the redeploys. This is relative to
+      # the applications root (the directory that the rackup file lives
+      # in). Touch this file to redepoy the application.
+      watch "REVISION"
+    end
+
+    rack "/path/to/another/rackup/config.ru" do
+      # More settings here
+    end
+
+Once you have Kirk configured, start it up with the following command:
+
+    kirk -c /path/to/Kirkfile
+
+... and you're off.
+
+### Daemonizing Kirk
+
+Use your OS features. For example, write an upstart script or use
+`start-stop-daemon`.
+
+### Logging to a file or syslog
+
+Kirk just dumps logs to stdout, so just pipe Kirk to `logger`.
+
+### Caveats
+
+This is still a pretty new project and a lot of settings that should be
+abstracted are still hardcoded in the source.
+
+* Kirk requires JRuby 1.6.0 RC 1 or greater. This is due to a JRuby bug that
+  was fixed in the 1.6 branch but never backported to older versions of JRuby.
+  Crazy stuff happens without the bug fix.
+
+* The JDBC drivers will keep connections open unless they are explicitly
+  cleaned up, something which Rack applications do not do. A future release of
+  the jdbc ruby drivers will correctly clean up after the JDBC garbage, but for
+  now, you will have to manually do it. If you are running a Rails app, add the
+  following to the config.ru file:
+
+      at_exit { ActiveRecord::Base.clear_all_connections! }
+
+### Getting Help
+
+Ping me (carllerche) on Freenode in #carlhuda
+
+### Reporting Bugs
+
+Just post them to the Github repository's issue tracker.

data/bin/kirk

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'kirk/cli'
+Kirk::CLI.start(ARGV)

data/lib/kirk.rb

@@ -0,0 +1,55 @@
+module Kirk
+  # Make sure that the version of JRuby is new enough
+  unless (JRUBY_VERSION.split('.')[0..2].map(&:to_i) <=> [1, 6, 0]) >= 0
+    raise "Kirk requires JRuby 1.6.0 RC 1 or greater. This is due to "   \
+          "a bug that was fixed in the 1.6 line but not backported to "  \
+          "older versions of JRuby. If you want to use Kirk with older " \
+          "versions of JRuby, bug headius."
+  end
+
+  require 'java'
+  require 'kirk/native'
+  require 'kirk/jetty'
+  require 'kirk/version'
+
+  import "java.util.concurrent.LinkedBlockingQueue"
+  import "java.util.concurrent.TimeUnit"
+  import "java.util.logging.Logger"
+  import "java.util.logging.Level"
+  import "java.util.logging.ConsoleHandler"
+
+  module Native
+    import "com.strobecorp.kirk.ApplicationConfig"
+    import "com.strobecorp.kirk.HotDeployableApplication"
+    import "com.strobecorp.kirk.LogFormatter"
+  end
+
+  module Applications
+    autoload :Config,         'kirk/applications/config'
+    autoload :DeployWatcher,  'kirk/applications/deploy_watcher'
+    autoload :HotDeployable,  'kirk/applications/hot_deployable'
+    autoload :Rack,           'kirk/applications/rack'
+  end
+
+  require 'kirk/builder'
+  require 'kirk/handler'
+  require 'kirk/input_stream'
+  require 'kirk/server'
+
+  # Configure the logger
+  def self.logger
+    @logger ||= begin
+      logger = Logger.get_logger("org.eclipse.jetty.util.log")
+      logger.set_use_parent_handlers(false)
+      logger.add_handler logger_handler
+      logger
+    end
+  end
+
+  def self.logger_handler
+    ConsoleHandler.new.tap do |handler|
+      handler.set_output_stream(java::lang::System.out)
+      handler.set_formatter(Native::LogFormatter.new)
+    end
+  end
+end

data/lib/kirk/applications/config.rb

@@ -0,0 +1,28 @@
+module Kirk
+  module Applications
+    class Config
+      include Native::ApplicationConfig
+
+      attr_accessor :hosts,
+                    :listen,
+                    :watch,
+                    :rackup,
+                    :application_path,
+                    :bootstrap_path
+
+      def initialize
+        @hosts  = []
+        @listen = listen
+      end
+
+      def application_path
+        @application_path || File.dirname(rackup)
+      end
+
+      # Handle the java interface
+      alias getApplicationPath    application_path
+      alias getRackupPath         rackup
+      alias getBootstrapPath      bootstrap_path
+    end
+  end
+end

data/lib/kirk/applications/deploy_watcher.rb

@@ -0,0 +1,138 @@
+module Kirk
+  class Applications::DeployWatcher
+    include Jetty::LifeCycle::Listener
+
+    def initialize
+      @apps, @magic_telephone, @workers = [], LinkedBlockingQueue.new, 0
+      @info   = {}
+      @thread = Thread.new { run_loop }
+      @thread.abort_on_exception = true
+    end
+
+    def stop
+      @magic_telephone.put :halt
+      @thread.join
+    end
+
+    def life_cycle_started(app)
+      @magic_telephone.put [ :watch, app ]
+    end
+
+    def life_cycle_stopping(app)
+      @magic_telephone.put [ :unwatch, app ]
+    end
+
+    # Rest of the java interface
+    def life_cycle_failure(app, cause)  ; end
+    def life_cycle_starting(app)        ; end
+    def life_cycle_stopped(app)         ; end
+
+  private
+
+    def run_loop
+      while true
+        # First, pull off messages
+        while msg = @magic_telephone.poll(50, TimeUnit::MILLISECONDS)
+          return if msg == :halt
+          handle_message(*msg)
+        end
+
+        check_apps
+      end
+
+      until @workers == 0
+        msg = @magic_telephone.take
+        handle_message(*msg)
+      end
+
+      cleanup
+    end
+
+    def handle_message(action, *args)
+      case action
+      when :watch
+
+        app, _ = *args
+
+        @apps |= [app]
+
+        @info[app] ||= {
+          :standby       => LinkedBlockingQueue.new,
+          :last_modified => app.last_modified
+        }
+
+        warmup_standby_deploy(app)
+
+      when :unwatch
+
+        app, _ = *args
+        @apps.delete(app)
+
+      when :worker_complete
+
+        @workers -= 1
+
+      else
+
+        raise "Unknown action `#{action}`"
+
+      end
+    end
+
+    def check_apps
+      @apps.each do |app|
+        new_last_modified = app.last_modified
+        info = @info[app]
+
+        if new_last_modified > info[:last_modified]
+          Kirk.logger.info("Reloading `#{app.application_path}`")
+          redeploy(app, new_last_modified)
+        end
+      end
+    end
+
+    def redeploy(app, mtime)
+      if key = app.key
+
+        queue  = @info[app][:standby]
+        deploy = queue.poll
+
+        if deploy && deploy.key == key
+          app.deploy(deploy)
+        else
+          deploy.terminate if deploy
+          app.redeploy
+        end
+
+        warmup_standby_deploy(app)
+      else
+        app.redeploy
+      end
+
+      @info[app][:last_modified] = mtime
+    end
+
+    def warmup_standby_deploy(app)
+      queue = @info[app][:standby]
+      background { queue.put(app.build_deploy) }
+    end
+
+    def cleanup
+      @apps.each do |app|
+        queue = @info[app][:standby]
+
+        while deploy = queue.poll
+          deploy.terminate
+        end
+      end
+    end
+
+    def background
+      @workers += 1
+      Thread.new do
+        yield
+        @magic_telephone.put [ :worker_complete ]
+      end
+    end
+  end
+end

data/lib/kirk/applications/hot_deployable.rb

@@ -0,0 +1,50 @@
+require 'digest/sha1'
+
+module Kirk
+  module Applications
+    # This class extends a native Java class
+    class HotDeployable < Native::HotDeployableApplication
+
+      def initialize(config)
+        super(config)
+        redeploy
+      end
+
+      def key
+        gemfile  = "#{application_path}/Gemfile"
+        lockfile = "#{application_path}/Gemfile.lock"
+
+        if File.exist?(gemfile) && File.exist?(lockfile)
+          str = File.read(gemfile) + File.read(lockfile)
+          Digest::SHA1.hexdigest(str)
+        end
+      end
+
+      def add_watcher(watcher)
+        add_life_cycle_listener(watcher)
+      end
+
+      def application_path
+        config.application_path
+      end
+
+      def last_modified
+        mtimes = config.watch.map do |path|
+          path = File.expand_path(path, application_path)
+          File.exist?(path) ? File.mtime(path).to_i : 0
+        end
+
+        mtimes.max
+      end
+
+      def redeploy
+        deploy(build_deploy)
+      end
+
+      def deploy(d)
+        d.prepare
+        super(d)
+      end
+    end
+  end
+end

data/lib/kirk/applications/rack.rb

@@ -0,0 +1,21 @@
+gem "rack", ">= 1.0.0"
+require "rack"
+
+module Kirk
+  module Applications
+    # This class extends a native Java class
+    class Rack < Jetty::AbstractHandler
+      def self.new(app)
+        inst     = super()
+        inst.app = Handler.new(app)
+        inst
+      end
+
+      attr_accessor :app
+
+      def handle(target, base_request, request, response)
+        app.handle(target, base_request, request, response)
+      end
+    end
+  end
+end

data/lib/kirk/bootstrap.rb

@@ -0,0 +1,62 @@
+require 'java'
+
+module Kirk
+  import 'java.util.zip.GZIPInputStream'
+  import 'java.util.zip.InflaterInputStream'
+
+  class Bootstrap
+    def warmup(application_path)
+      Dir.chdir File.expand_path(application_path)
+
+      load_rubygems
+
+      load_bundle.tap do
+        add_kirk_to_load_path
+
+        load_rack
+        load_kirk
+      end
+    end
+
+    def run(rackup)
+      app, options = Rack::Builder.parse_file(rackup)
+
+      Kirk::Handler.new(app)
+    end
+
+  private
+
+    def load_rubygems
+      require 'rubygems'
+    end
+
+    def load_bundle
+      if File.exist?('Gemfile')
+        require 'bundler/setup'
+
+        if File.exist?('Gemfile.lock')
+          require 'digest/sha1'
+          str = File.read('Gemfile') + File.read('Gemfile.lock')
+          Digest::SHA1.hexdigest(str)
+        end
+      end
+    end
+
+    def add_kirk_to_load_path
+      $:.unshift File.expand_path('../..', __FILE__)
+    end
+
+    def load_rack
+      gem "rack", ">= 1.0.0"
+      require 'rack'
+    end
+
+    def load_kirk
+      require 'kirk/version'
+      require 'kirk/input_stream'
+      require 'kirk/handler'
+    end
+  end
+end
+
+Kirk::Bootstrap.new

data/lib/kirk/builder.rb

@@ -0,0 +1,133 @@
+module Kirk
+  class MissingConfigFile < RuntimeError ; end
+  class MissingRackupFile < RuntimeError ; end
+
+  class Builder
+
+    VALID_LOG_LEVELS = %w(severe warning info config fine finer finest all)
+
+    attr_reader :options
+
+    def initialize(root = nil)
+      @root    = root || Dir.pwd
+      @current = nil
+      @configs = []
+      @options = { :watcher => Applications::DeployWatcher.new }
+    end
+
+    def load(path)
+      path = expand_path(path)
+
+      with_root File.dirname(path) do
+        unless File.exist?(path)
+          raise MissingConfigFile, "config file `#{path}` does not exist"
+        end
+
+        instance_eval(File.read(path), path)
+      end
+    end
+
+    def log(opts = {})
+      level = opts[:level]
+      raise "Invalid log level" unless VALID_LOG_LEVELS.include?(level.to_s)
+      @options[:log_level] = level.to_s
+    end
+
+    def rack(rackup)
+      rackup = expand_path(rackup)
+
+      unless File.exist?(rackup)
+        raise MissingRackupFile, "rackup file `#{rackup}` does not exist"
+      end
+
+      @current = new_config
+      @current.rackup = rackup
+
+      yield if block_given?
+
+    ensure
+      @configs << @current
+      @current = nil
+    end
+
+    def hosts(*hosts)
+      @current.hosts.concat hosts
+    end
+
+    def listen(listen)
+      listen = listen.to_s
+      listen = ":#{listen}" unless listen.index(':')
+      listen = "0.0.0.0#{listen}" if listen.index(':') == 0
+
+      @current.listen = listen
+    end
+
+    def watch(*watch)
+      @current.watch = watch
+    end
+
+    def to_handler
+      handlers = @configs.map do |c|
+        Jetty::ContextHandler.new.tap do |ctx|
+          # Set the virtual hosts
+          unless c.hosts.empty?
+            ctx.set_virtual_hosts(c.hosts)
+          end
+
+          application = Applications::HotDeployable.new(c)
+          application.add_watcher(watcher)
+
+          ctx.set_connector_names [c.listen]
+          ctx.set_handler application
+        end
+      end
+
+      Jetty::ContextHandlerCollection.new.tap do |collection|
+        collection.set_handlers(handlers)
+      end
+    end
+
+    def to_connectors
+      @connectors = {}
+
+      @configs.each do |config|
+        next if @connectors.key?(config.listen)
+
+        host, port = config.listen.split(':')
+
+        connector = Jetty::SelectChannelConnector.new
+        connector.set_host(host)
+        connector.set_port(port.to_i)
+
+        @connectors[config.listen] = connector
+      end
+
+      @connectors.values
+    end
+
+  private
+
+    def watcher
+      @options[:watcher]
+    end
+
+    def with_root(root)
+      old, @root = @root, root
+      yield
+    ensure
+      @root = old
+    end
+
+    def expand_path(path)
+      File.expand_path(path, @root)
+    end
+
+    def new_config
+      Applications::Config.new.tap do |config|
+        config.listen         = '0.0.0.0:9090'
+        config.watch          = [ 'REVISION' ]
+        config.bootstrap_path = File.expand_path('../bootstrap.rb', __FILE__)
+      end
+    end
+  end
+end

data/lib/kirk/cli.rb

@@ -0,0 +1,52 @@
+require 'kirk'
+require 'optparse'
+
+module Kirk
+  class CLI
+    def self.start(argv)
+      new(argv).tap { |inst| inst.run }
+    end
+
+    def initialize(argv)
+      @argv    = argv.dup
+      @options = default_options
+    end
+
+    def run
+      parse!
+
+      server = Kirk::Server.build(config)
+      server.start
+      server.join
+    rescue Exception => e
+      abort "[ERROR] #{e.message}"
+    end
+
+  private
+
+    def config
+      @options[:config]
+    end
+
+    def default_options
+      { :config => "#{Dir.pwd}/Kirkfile" }
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: kirk [options] <command> [<args>]"
+
+        opts.separator ""
+        opts.separator "Server options:"
+
+        opts.on("-c", "--config FILE",  "Load options from a config file") do |file|
+          @options[:config] = file
+        end
+      end
+    end
+
+    def parse!
+      parser.parse! @argv
+    end
+  end
+end

data/lib/kirk/handler.rb

@@ -0,0 +1,126 @@
+module Kirk
+  class Handler
+    # Required environment variable keys
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    SCRIPT_NAME    = 'SCRIPT_NAME'.freeze
+    PATH_INFO      = 'PATH_INFO'.freeze
+    QUERY_STRING   = 'QUERY_STRING'.freeze
+    SERVER_NAME    = 'SERVER_NAME'.freeze
+    SERVER_PORT    = 'SERVER_PORT'.freeze
+    CONTENT_TYPE   = 'CONTENT_TYPE'.freeze
+    CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze
+    REQUEST_URI    = 'REQUEST_URI'.freeze
+    REMOTE_HOST    = 'REMOTE_HOST'.freeze
+    REMOTE_ADDR    = 'REMOTE_ADDR'.freeze
+    REMOTE_USER    = 'REMOTE_USER'.freeze
+
+    # Rack specific variable keys
+    RACK_VERSION      = 'rack.version'.freeze
+    RACK_URL_SCHEME   = 'rack.url_scheme'.freeze
+    RACK_INPUT        = 'rack.input'.freeze
+    RACK_ERRORS       = 'rack.errors'.freeze
+    RACK_MULTITHREAD  = 'rack.multithread'.freeze
+    RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+    RACK_RUN_ONCE     = 'rack.run_once'.freeze
+    HTTP_PREFIX       = 'HTTP_'.freeze
+
+    # Rack response header names
+    CONTENT_TYPE_RESP   = 'Content-Type'
+    CONTENT_LENGTH_RESP = 'Content-Length'
+
+    # Kirk information
+    SERVER          = "#{NAME} #{VERSION}".freeze
+    SERVER_SOFTWARE = 'SERVER_SOFTWARE'.freeze
+
+    DEFAULT_RACK_ENV = {
+      SERVER_SOFTWARE => SERVER,
+
+      # Rack stuff
+      RACK_ERRORS       => STDERR,
+      RACK_MULTITHREAD  => true,
+      RACK_MULTIPROCESS => false,
+      RACK_RUN_ONCE     => false,
+    }
+
+    CONTENT_LENGTH_TYPE_REGEXP = /^Content-(?:Type|Length)$/i
+
+    def initialize(app)
+      @app = app
+    end
+
+    def handle(target, base_request, request, response)
+      begin
+        env = DEFAULT_RACK_ENV.merge(
+          REQUEST_URI     => request.getRequestURI,
+          PATH_INFO       => request.get_path_info,
+          REQUEST_METHOD  => request.get_method       || "GET",
+          RACK_URL_SCHEME => request.get_scheme       || "http",
+          QUERY_STRING    => request.get_query_string || "",
+          SERVER_NAME     => request.get_server_name  || "",
+          REMOTE_HOST     => request.get_remote_host  || "",
+          REMOTE_ADDR     => request.get_remote_addr  || "",
+          REMOTE_USER     => request.get_remote_user  || "",
+          SERVER_PORT     => request.get_server_port.to_s,
+          RACK_VERSION    => ::Rack::VERSION)
+
+        # Process the content length
+        if (content_length = request.get_content_length) >= 0
+          env[CONTENT_LENGTH] = content_length.to_s
+        else
+          env[CONTENT_LENGTH] = "0"
+        end
+
+        if (content_type = request.get_content_type)
+          env[CONTENT_TYPE] = content_type unless content_type == ''
+        end
+
+        request.get_header_names.each do |header|
+          next if header =~ CONTENT_LENGTH_TYPE_REGEXP
+          value = request.get_header(header)
+
+          header.tr! '-', '_'
+          header.upcase!
+
+          header      = "#{HTTP_PREFIX}#{header}"
+          env[header] = value unless env.key?(header) || value == ''
+        end
+
+        input = request.get_input_stream
+
+        case env['HTTP_CONTENT_ENCODING']
+        when 'deflate' then input = InflaterInputStream.new(input)
+        when 'gzip'    then input = GZIPInputStream.new(input)
+        end
+
+        input = InputStream.new(input)
+        env[RACK_INPUT] = input
+
+        # Dispatch the request
+        status, headers, body = @app.call(env)
+
+        response.set_status(status.to_i)
+
+        headers.each do |header, value|
+          case header
+          when CONTENT_TYPE_RESP
+            response.set_content_type(value)
+          when CONTENT_LENGTH_RESP
+            response.set_content_length(value.to_i)
+          else
+            response.set_header(header, value)
+          end
+        end
+
+        buffer = response.get_output_stream
+        body.each do |s|
+          buffer.write(s.to_java_bytes)
+        end
+
+        body.close if body.respond_to?(:close)
+      ensure
+        input.recycle if input
+        request.set_handled(true)
+      end
+    end
+  end
+end

data/lib/kirk/input_stream.rb

@@ -0,0 +1,261 @@
+require 'java'
+
+module Kirk
+  class InputStream
+    READL_SIZE  = 1_024
+    CHUNK_SIZE  = 8_192
+    BUFFER_SIZE = 1_024 * 50
+
+    import "java.io.File"
+    import "java.io.RandomAccessFile"
+    import "java.nio.ByteBuffer"
+    import "java.nio.channels.Channels"
+
+    # For our ROFL scale needs
+    import "java.util.concurrent.LinkedBlockingQueue"
+
+    BUFFER_POOL    = LinkedBlockingQueue.new
+    TMPFILE_PREFIX = "rackinput".to_java_string
+    TMPFILE_SUFFIX = "".to_java_string
+
+    def initialize(io)
+      @io       = channelize(io)
+      @buffer   = grab_buffer
+      @filebuf  = nil
+      @read     = 0
+      @position = 0
+      @eof      = false
+    end
+
+    def read(size = nil, buffer = nil)
+      one_loop = nil
+      read_all = size.nil?
+
+      buffer ? buffer.slice!(0..-1) : buffer = ''
+
+      raise ArgumentError, "negative length #{size} given" if size && size < 0
+
+      loop do
+        limit = size && size < CHUNK_SIZE ? size : CHUNK_SIZE
+
+        len = read_chunk(limit, buffer)
+
+        break unless len
+
+        one_loop = true
+
+        break if size && ( size -= len ) <= 0
+      end
+
+      return "" if read_all && !one_loop
+
+      one_loop && buffer
+    end
+
+    def gets(sep = $/)
+      return read unless sep
+
+      sep    = "#{$/}#{$/}" if sep == ""
+      buffer = ''
+      curpos = pos
+
+      while chunk = read(READL_SIZE)
+        buffer << chunk
+
+        if i = buffer.index(sep, 0)
+          i += sep.bytesize
+          buffer.slice!(i..-1)
+          seek(curpos + buffer.bytesize)
+          break
+        end
+      end
+
+      buffer
+    end
+
+    def each
+      while chunk = read(CHUNK_SIZE)
+        yield chunk
+      end
+
+      self
+    end
+
+    def pos
+      @position
+    end
+
+    def seek(pos)
+      raise Errno::EINVAL, "Invalid argument - invalid seek value" if pos < 0
+      @position = pos
+    end
+
+    def rewind
+      seek(0)
+    end
+
+    def close
+      nil
+    end
+
+    def recycle
+      BUFFER_POOL.put(@buffer)
+      @buffer = nil
+      nil
+    end
+
+  private
+
+    def channelize(stream)
+      Channels.new_channel(stream)
+    end
+
+    def grab_buffer
+      BUFFER_POOL.poll || ByteBuffer.allocate(BUFFER_SIZE)
+    end
+
+    def read_chunk(size, string)
+      missing = size - ( @read - @position )
+
+      if @filebuf || @read + missing > BUFFER_SIZE
+
+        rotate_to_tmp_file unless @filebuf
+        read_chunk_from_tmp_file(size, string)
+
+      else
+
+        read_chunk_from_mem(missing, string)
+
+      end
+    end
+
+    def read_chunk_from_mem(missing, string)
+      # We gonna have to read from the input stream
+      if missing > 0 && !@eof
+
+        # Set the new buffer limit to the amount that is going
+        # to be read
+        @buffer.position(@read).limit(@read + missing)
+
+        # Read into the buffer
+        len = @io.read(@buffer)
+
+        # Bail if we're at the EOF
+        if len == -1
+          @eof = true
+          return
+        end
+
+        @read += len
+
+      # We're at the end
+      elsif @position == @read
+
+        return
+
+      end
+
+      # Now move the amount read into the string
+      @buffer.position(@position).limit(@read)
+
+      append_buffer_to_string(@buffer, string)
+    end
+
+    def read_chunk_from_tmp_file(size, string)
+
+      if @read < @position && !@eof
+
+        return unless buffer_to(@position)
+
+      end
+
+      @buffer.clear.limit(size)
+
+      if @read > @position
+
+        @filebuf.position(@position)
+        @filebuf.read(@buffer)
+
+      elsif @eof
+
+        return
+
+      end
+
+      unless @eof
+
+        offset = @buffer.position
+        len    = @io.read(@buffer)
+
+        if len == -1
+
+          @eof = true
+          return if offset == 0
+
+        else
+
+          @filebuf.position(@read)
+          @filebuf.write(@buffer.flip.position(offset))
+
+          @read += len
+
+        end
+
+        @buffer.position(0)
+
+      end
+
+      append_buffer_to_string(@buffer, string)
+    end
+
+    def buffer_to(position)
+      until @read == position
+        limit = position - @read
+        limit = BUFFER_SIZE if limit > BUFFER_SIZE
+
+        @buffer.clear.limit(limit)
+
+        len = @io.read(@buffer)
+
+        if len == -1
+          @eof = true
+          return
+        end
+
+        @buffer.flip
+
+        @filebuf.position(@read)
+        @filebuf.write(@buffer)
+
+        @read += len
+      end
+
+      true
+    end
+
+    def append_buffer_to_string(buffer, string)
+      len   = buffer.limit - buffer.position
+      bytes = Java::byte[len].new
+      buffer.get(bytes)
+      string << String.from_java_bytes(bytes)
+      @position += len
+      len
+    end
+
+    def rotate_to_tmp_file
+      @buffer.position(0).limit(@read)
+
+      @filebuf = create_tmp_file
+      @filebuf.write @buffer
+
+      @buffer.clear
+    end
+
+    def create_tmp_file
+      file = File.create_temp_file(TMPFILE_PREFIX, TMPFILE_SUFFIX)
+      file.delete_on_exit
+
+      RandomAccessFile.new(file, "rw").channel
+    end
+  end
+end

data/lib/kirk/jetty.rb

@@ -0,0 +1,18 @@
+require "kirk/jetty/jetty-server-7.2.2.v20101205"
+require "kirk/jetty/servlet-api-2.5"
+
+module Kirk
+  module Jetty
+    # Gimme Jetty
+    import "org.eclipse.jetty.server.nio.SelectChannelConnector"
+    import "org.eclipse.jetty.server.handler.AbstractHandler"
+    import "org.eclipse.jetty.server.handler.ContextHandler"
+    import "org.eclipse.jetty.server.handler.ContextHandlerCollection"
+    import "org.eclipse.jetty.server.Server"
+    import "org.eclipse.jetty.util.component.LifeCycle"
+    import "org.eclipse.jetty.util.log.Log"
+    import "org.eclipse.jetty.util.log.JavaUtilLog"
+
+    Log.set_log Jetty::JavaUtilLog.new
+  end
+end

data/lib/kirk/server.rb

@@ -0,0 +1,96 @@
+module Kirk
+  class Server
+    def self.build(file = nil, &blk)
+      root    = File.dirname(file) if file
+      builder = Builder.new(root)
+
+      if file && !File.exist?(file)
+        raise MissingConfigFile, "config file `#{file}` does not exist"
+      end
+
+      file ? builder.instance_eval(File.read(file), file) :
+             builder.instance_eval(&blk)
+
+      options              = builder.options
+      options[:connectors] = builder.to_connectors
+
+      new(builder.to_handler, options)
+    end
+
+    def self.start(handler, options = {})
+      new(handler, options).tap do |server|
+        server.start
+      end
+    end
+
+    def initialize(handler, options = {})
+      if Jetty::AbstractHandler === handler
+        @handler = handler
+      elsif handler.respond_to?(:call)
+        @handler = Applications::Rack.new(handler)
+      else
+        raise "#{handler.inspect} is not a valid Rack application"
+      end
+
+      @options = options
+    end
+
+    def start
+      @server = Jetty::Server.new.tap do |server|
+        connectors.each do |conn|
+          server.add_connector(conn)
+        end
+
+        server.set_handler(@handler)
+      end
+
+      configure!
+
+      @server.start
+    end
+
+    def join
+      @server.join
+    end
+
+    def stop
+      watcher.stop if watcher
+      @server.stop
+    end
+
+  private
+
+    def configure!
+      Kirk.logger.set_level log_level
+    end
+
+    def connectors
+      @options[:connectors] ||=
+        [ Jetty::SelectChannelConnector.new.tap do |conn|
+          host = @options[:host] || '0.0.0.0'
+          port = @options[:port] || 9090
+
+          conn.set_host(host)
+          conn.set_port(port.to_i)
+        end ]
+    end
+
+    def watcher
+      @options[:watcher]
+    end
+
+    def log_level
+      case (@options[:log_level] || "info").to_s
+      when "severe"   then Level::SEVERE
+      when "warning"  then Level::WARNING
+      when "info"     then Level::INFO
+      when "config"   then Level::CONFIG
+      when "fine"     then Level::FINE
+      when "finer"    then Level::FINER
+      when "finest"   then Level::FINEST
+      when "all"      then Level::ALL
+      else Level::INFO
+      end
+    end
+  end
+end

data/lib/kirk/version.rb

@@ -0,0 +1,4 @@
+module Kirk
+  NAME    = "kirk".freeze
+  VERSION = "0.1.0".freeze
+end

data/lib/rack/handler/kirk.rb

@@ -0,0 +1,25 @@
+require 'kirk'
+require 'rack'
+
+module Rack
+  module Handler
+    class Kirk
+      def self.run(app, options = {})
+        options[:host] = options[:Host]
+        options[:port] = options[:Port]
+
+        options[:log_level] ||= "warning"
+
+        server = ::Kirk::Server.new(app, options)
+
+        yield server if block_given?
+
+        # Tears :'(
+        trap(:INT) { server.stop }
+
+        server.start
+        server.join
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: kirk
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: java
+authors: 
+  - Carl Lerche
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-02 00:00:00 -08:00
+default_executable: kirk
+dependencies: []
+
+description: |
+  Kirk is a wrapper around Jetty that hides all of the insanity and
+  wraps your Rack application in a loving embrace. Also, Kirk is
+  probably one of the least HTTP retarded ruby rack server out there.
+
+email: 
+  - me@carllerche.com
+executables: 
+  - kirk
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - lib/kirk.rb
+  - lib/kirk/bootstrap.rb
+  - lib/kirk/builder.rb
+  - lib/kirk/cli.rb
+  - lib/kirk/handler.rb
+  - lib/kirk/input_stream.rb
+  - lib/kirk/jetty.rb
+  - lib/kirk/server.rb
+  - lib/kirk/version.rb
+  - lib/kirk/applications/config.rb
+  - lib/kirk/applications/deploy_watcher.rb
+  - lib/kirk/applications/hot_deployable.rb
+  - lib/kirk/applications/rack.rb
+  - lib/rack/handler/kirk.rb
+  - lib/kirk/native.jar
+  - lib/kirk/jetty/jetty-server-7.2.2.v20101205.jar
+  - lib/kirk/jetty/servlet-api-2.5.jar
+  - bin/kirk
+  - README.md
+  - LICENSE
+has_rdoc: true
+homepage: http://github.com/carllerche/kirk
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.6
+requirements: []
+
+rubyforge_project: kirk
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A JRuby Rack Server Based on Jetty
+test_files: []
+