jubilee 0.1.2

data/lib/jubilee/const.rb

@@ -0,0 +1,39 @@
+module Jubilee
+  module Const
+    JUBILEE_VERSION = VERSION = "0.1.0".freeze
+    HTTP_11 = "HTTP/1.1".freeze
+    HTTP_10 = "HTTP/1.0".freeze
+
+    SERVER_SOFTWARE = "SERVER_SOFTWARE".freeze
+    SERVER_PROTOCOL = "SERVER_PROTOCOL".freeze
+    GATEWAY_INTERFACE = "GATEWAY_INTERFACE".freeze
+    SERVER_NAME = "SERVER_NAME".freeze
+    SERVER_PORT = "SERVER_PORT".freeze
+
+    CGI_VER = "CGI/1.2".freeze
+
+    RACK_INPUT = "rack.input".freeze
+
+    REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+    GET = 'GET'.freeze
+    POST = "POST".freeze
+    REQUEST_PATH = "REQUEST_PATH".freeze
+    REQUEST_URI = "REQUEST_URI".freeze
+    PATH_INFO = "PATH_INFO".freeze
+    QUERY_STRING = "QUERY_STRING".freeze
+
+    CONTENT_LENGTH = "Content-Length".freeze
+    TRANSFER_ENCODING = "Transfer-Encoding".freeze
+
+    HTTP_VERSION = "HTTP_VERSION".freeze
+    HTTP_HOST = "HTTP_HOST".freeze
+    HTTP_USER_AGENT = "HTTP_USER_AGENT".freeze
+    HTTP_ACCEPT = "HTTP_ACCEPT".freeze
+    HTTP_COOKIE = "HTTP_COOKIE".freeze
+    HTTP_ACCEPT_LANGUAGE = "HTTP_ACCEPT_LANGUAGE".freeze
+    HTTP_ACCEPT_ENCODING = "HTTP_ACCEPT_ENCODING".freeze
+    HTTP_CONNECTION = "HTTP_CONNECTION".freeze
+
+    STATUS_WITH_NO_ENTITY_BODY = Hash[Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.map{|s| [s, true]}]
+  end
+end

data/lib/jubilee/response.rb

@@ -0,0 +1,64 @@
+require 'java'
+module Jubilee
+  class Response
+    include Const
+    include org.jruby.jubilee.RackResponse
+
+    def initialize(array)
+      @status, @headers, @body = *array
+      @content_length = nil
+      if @body.kind_of? Array and @body.size == 1
+        @content_length = @body[0].bytesize
+      end
+    end
+
+    def respond(response)
+      no_body = @status < 200 || STATUS_WITH_NO_ENTITY_BODY[@status]
+      write_status(response)
+      write_headers(response)
+      if no_body
+        response.end
+      else 
+        if @body.respond_to?(:to_path)
+          response.sendFile(@body.to_path)
+        else
+          write_body(response)
+          response.end
+        end
+      end
+    ensure
+      @body.close if @body.respond_to?(:close)
+    end
+
+    private
+    def write_status(response)
+      response.statusCode = @status
+    end
+
+    def write_headers(response)
+      @headers.each do |key, value|
+        case key
+        when CONTENT_LENGTH
+          @content_length = value
+          next
+        when TRANSFER_ENCODING
+          @allow_chunked = false
+          @content_length = nil
+        end
+        response.putHeader(key, value)
+      end
+    end
+
+    def write_body(response)
+      if @content_length
+        response.putHeader(CONTENT_LENGTH, @content_length.to_s)
+      else
+        response.setChunked(true)
+      end
+
+      @body.each do |part|
+        response.write(part)
+      end
+    end
+  end
+end

data/lib/jubilee/server.rb

@@ -0,0 +1,16 @@
+module Jubilee
+  class Server < VertxServer
+    def initialize(app, opts = {})
+      options = {port: 3215, ssl: false}.merge(opts)
+      if (options[:ssl])
+        if options[:keystore].nil?
+          raise ArgumentError, "Please provide a keystore for ssl"
+        else
+          super(Application.new(app), options[:port], options[:ssl], options[:keystore], options[:keystore_password])
+        end
+      else
+        super(Application.new(app), options[:port])
+      end
+    end
+  end
+end

data/lib/rack/handler/jubilee.rb

@@ -0,0 +1,43 @@
+require 'rack/handler'
+require 'jubilee'
+require 'java'
+
+module Rack
+  module Handler
+    module Jubilee
+      DEFAULT_OPTIONS = {
+        :host => '0.0.0.0',
+        :port => 3000,
+        :verbose => false
+      }
+      def self.run(app, options = {})
+        options = DEFAULT_OPTIONS.merge(options)
+
+        if options[:verbose]
+          app = Rack::CommonLogger.new(app, STDOUT)
+        end
+
+        if options[:environment]
+          ENV["RACK_ENV"] = options[:environment].to_s
+        end
+
+        @server = ::Jubilee::Server.new(app, options)
+
+        puts "Jubilee starting..."
+        puts "Environment: #{ENV['RACK_ENV']}"
+
+        yield @server if block_given?
+
+        @server.start
+        @starter = org.jruby.jubilee.deploy.Starter.new
+        @starter.block
+      end
+
+      def self.shutdown
+        @server.stop{ @starter.unblock }
+        exit
+      end
+    end
+    register :jubilee, Jubilee
+  end
+end

data/test/.rbenv-version

@@ -0,0 +1 @@
+jruby-1.7.0

data/test/config/app.rb

@@ -0,0 +1,5 @@
+class App
+  def call(env)
+    [200, {"Content-Type" => "text/plain"}, ["embeded app"]]
+  end
+end

data/test/jubilee/test_cli.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+require 'jubilee/cli'
+
+class TestJubileeCLI < MiniTest::Unit::TestCase
+  def test_parse_options
+    cli = Jubilee::CLI.new(["app.rb"])
+    cli.parse_options
+    assert_equal "app.rb", cli.options[:rackup]
+    assert_equal 3215, cli.options[:port]
+  end
+end

data/test/jubilee/test_config.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+require 'jubilee/configuration'
+
+class TestConfig < MiniTest::Unit::TestCase
+  def setup
+    @config = Jubilee::Configuration.new({rackup: "config/app.rb"})
+  end
+  def test_load
+    @config.load
+    resp = [200, {"Content-Type" => "text/plain"}, ["embeded app"]]
+    skip "hard to test because of Rack::Lint"
+    #assert_equal resp, @config.app.call({})
+  end
+end

data/test/jubilee/test_persistent.rb

@@ -0,0 +1,238 @@
+require 'test_helper'
+require 'timeout'
+require 'socket'
+class TestPersistent < MiniTest::Unit::TestCase
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @close_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: close\r\n\r\n"
+    @http10_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    @keep_request = "GET / HTTP/1.0\r\nHost: test.com\r\nContent-Type: text/plain\r\nConnection: Keep-Alive\r\n\r\n"
+
+    @valid_post = "POST / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello"
+    @valid_no_body = "GET / HTTP/1.1\r\nHost: test.com\r\nX-Status: 204\r\nContent-Type: text/plain\r\n\r\n"
+
+    @headers = { "X-Header" => "Works" }
+    @body = ["Hello"]
+    @inputs = []
+
+    @simple = lambda do |env|
+      @inputs << env['rack.input']
+      status = Integer(env['HTTP_X_STATUS'] || 200)
+      [status, @headers, @body]
+    end
+
+    @host = "127.0.0.1"
+    @port = 3215
+
+    @server = Jubilee::Server.new @simple
+    @server.start
+
+    @client = TCPSocket.new @host, @port
+  end
+
+  def teardown
+    @client.close
+    sleep 0.1 # in case server shutdown before request is submitted
+    @server.stop
+  end
+
+  def lines(count, s=@client)
+    str = ""
+    timeout(5) do
+      count.times { str << s.gets }
+    end
+    str
+  end
+
+  def test_one_with_content_length
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match Regexp.new("HTTP/1.1 200 OK\r\nContent-Length: #{sz}\r\nX-Header: Works\r\n\r\n", true), lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_two_back_to_back
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match Regexp.new("HTTP/1.1 200 OK\r\nContent-Length: #{sz}\r\nX-Header: Works\r\n\r\n", true), lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match Regexp.new("HTTP/1.1 200 OK\r\nContent-Length: #{sz}\r\nX-Header: Works\r\n\r\n", true), lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_post_then_get
+    @client << @valid_post
+    sz = @body[0].size.to_s
+
+    assert_match Regexp.new("HTTP/1.1 200 OK\r\nContent-Length: #{sz}\r\nX-Header: Works\r\n\r\n", true), lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_match Regexp.new("HTTP/1.1 200 OK\r\nContent-Length: #{sz}\r\nX-Header: Works\r\n\r\n", true), lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  #def test_no_body_then_get
+  #  @client << @valid_no_body
+  #  assert_equal "HTTP/1.1 204 No Content\r\nX-Header: Works\r\n\r\n", lines(3)
+
+  #  @client << @valid_request
+  #  sz = @body[0].size.to_s
+
+  #  assert_equal "HTTP/1.1 200 OK\r\nX-Header: Works\r\nContent-Length: #{sz}\r\n\r\n", lines(4)
+  #  assert_equal "Hello", @client.read(5)
+  #end
+
+  def test_chunked
+    @body << "Chunked"
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nx-header: Works\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n7\r\nChunked\r\n0\r\n\r\n", lines(10)
+  end
+
+  def test_no_chunked_in_http10
+    @body << "Chunked"
+
+    @client << @http10_request
+
+     assert_equal "HTTP/1.0 200 OK\r\nConnection: close\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "HelloChunked", @client.read
+  end
+
+  def test_hex
+    str = "This is longer and will be in hex"
+    @body << str
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nx-header: Works\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello\r\n#{str.size.to_s(16)}\r\n#{str}\r\n0\r\n\r\n", lines(10)
+
+  end
+
+  def test_client11_close
+    @client << @close_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\nConnection: close\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(5)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_client10_close
+    @client << @http10_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.0 200 OK\r\nConnection: close\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(5)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_one_with_keep_alive_header
+    @client << @keep_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.0 200 OK\r\nConnection: keep-alive\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(5)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_persistent_timeout
+    @server.persistent_timeout = 2
+    @client << @valid_request
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    sleep 3
+
+    assert_raises EOFError do
+      @client.read_nonblock(1)
+    end
+  end
+
+  def test_app_sets_content_length
+    @body = ["hello", " world"]
+    @headers['Content-Length'] = "11"
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: 11\r\nx-header: Works\r\n\r\n",
+                 lines(4)
+    assert_equal "hello world", @client.read(11)
+  end
+
+  def test_allow_app_to_chunk_itself
+    skip "vertx doesn't support chunk self yet"
+    @headers = {'Transfer-Encoding' => "chunked" }
+
+    @body = ["5\r\nhello\r\n0\r\n\r\n"]
+
+    @client << @valid_request
+
+    assert_equal "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\n0\r\n\r\n", lines(7)
+  end
+
+
+  def test_two_requests_in_one_chunk
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+  end
+
+  def test_second_request_not_in_first_req_body
+    @server.persistent_timeout = 3
+
+    req = @valid_request.to_s
+    req << "GET /second HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+
+    @client << req
+
+    sz = @body[0].size.to_s
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4)
+    assert_equal "Hello", @client.read(5)
+
+    # Since rack process request before the body is ready, we cannot
+    # utilize this optimization
+    # assert_kind_of Jubilee::NullIO, @inputs[0]
+    # assert_kind_of Jubilee::NullIO, @inputs[1]
+  end
+
+  def test_keepalive_doesnt_starve_clients
+    sz = @body[0].size.to_s
+
+    @client << @valid_request
+
+    c2 = TCPSocket.new @host, @port
+    c2 << @valid_request
+
+    out = IO.select([c2], nil, nil, 1)
+
+    assert out, "select returned nil"
+    assert_equal c2, out.first.first
+
+    assert_equal "HTTP/1.1 200 OK\r\ncontent-length: #{sz}\r\nx-header: Works\r\n\r\n", lines(4, c2)
+    assert_equal "Hello", c2.read(5)
+  end
+end

data/test/jubilee/test_rack_server.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+require 'rack/lint'
+require 'rack/commonlogger'
+
+class TestRackServer < MiniTest::Unit::TestCase
+
+  class ErrorChecker
+    def initialize(app)
+      @app = app
+      @exception = nil
+      @env = nil
+    end
+
+    attr_reader :exception, :env
+
+    def call(env)
+      begin
+        @env = env
+        return @app.call(env)
+      rescue Exception => e
+        @exception = e
+
+        [
+          500,
+          { "X-Exception" => e.message, "X-Exception-Class" => e.class.to_s },
+          ["Error detected"]
+        ]
+      end
+    end
+  end
+
+  class ServerLint < Rack::Lint
+    def call(env)
+      assert("No env given") { env }
+      check_env env
+
+      @app.call(env)
+    end
+  end
+
+  def setup
+    @valid_request = "GET / HTTP/1.1\r\nHost: test.com\r\nContent-Type: text/plain\r\n\r\n"
+    
+    @simple = lambda { |env| [200, { "X-Header" => "Works" }, ["Hello"]] }
+    @checker = ErrorChecker.new ServerLint.new(@simple)
+  end
+
+  def teardown
+    @server.stop
+  end
+
+  def test_lint
+    @server = Jubilee::Server.new @checker
+
+    @server.start
+
+    hit(['http://127.0.0.1:3215/test'])
+
+    if exc = @checker.exception
+      raise exc
+    end
+  end
+
+  def test_large_post_body
+    @checker = ErrorChecker.new ServerLint.new(@simple)
+    @server = Jubilee::Server.new @checker
+
+    @server.start
+
+    big = "x" * (1024 * 16)
+
+    Net::HTTP.post_form URI.parse('http://127.0.0.1:3215/test'),
+                 { "big" => big }
+
+    if exc = @checker.exception
+      raise exc
+    end
+  end
+
+  def test_path_info
+    input = nil
+    @server = Jubilee::Server.new (lambda { |env| input = env; @simple.call(env) })
+    @server.start
+
+    hit(['http://127.0.0.1:3215/test/a/b/c'])
+
+    assert_equal "/test/a/b/c", input['PATH_INFO']
+  end
+
+  def test_query_string
+    input = nil
+    @server = Jubilee::Server.new (lambda { |env| input = env; @simple.call(env) })
+    @server.start
+
+    hit(['http://127.0.0.1:3215/test/a/b/c?foo=bar'])
+
+    assert_equal "foo=bar", input['QUERY_STRING']
+  end
+
+  def test_post_data
+    require 'rack/request'
+    input = nil
+    @server = Jubilee::Server.new (lambda { |env| input = env; @simple.call(env) })
+    @server.start
+
+    req = Net::HTTP::Post::Multipart.new("/", "foo" => "bar")
+    resp = Net::HTTP.start('localhost', 3215) do |http|
+      http.request req
+    end
+
+    #Net::HTTP.post_form URI.parse('http://127.0.0.1:3215/test'), { "foo" => "bar" }
+
+    request = Rack::Request.new input
+    assert_equal "bar", request.params["foo"]
+  end
+end