thick 0.0.4-java

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+## 0.4 (xy.xz.2012)
+
+* make gem Java specific
+* copy-less request body container
+* async responses
+
+## 0.3 (26.3.2012)
+
+Update Netty to 3.4.0.Alpha2
+
+## 0.2 (26.3.2012)
+
+First public version
+
+## 0.1 (26.3.2012)
+
+Claim the gem ;)

data/LICENSE

@@ -0,0 +1,22 @@
+Portions copyright (c) 2012 Marek Jelen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# Thick
+
+Thick is very lightweight web server for JRuby based on excellent Netty library.
+
+## Status
+
+Works on several Sinatra and Rails applications. No real testing, yet.
+
+## Speed
+
+see PERFORMANCE.md
+
+## Interfaces
+
+Thick provides interfaces to control it's behaviour.
+
+### Asynchronous responses
+
+Asynchronous responses provide functionality to stream response to the client by chunks.
+
+The most basic API looks
+
+    env['thick.async'].async!(*params, &block)
+
+the application has to respond in a standard manner
+
+    [status, headers, body]
+
+the response will be processed and send to the client, however the connection is not closed, instead the block is
+executed with parameters passed as params. From the block the application can stream data to the client
+
+    env['thick.async'].call(chunk)
+
+after the response is completed the application has to close the connection
+
+    env['thick.async'].close
+
+In more complex scenarios the params and block may be omitted. It's up to the application to wait till the response
+header is sent to the client and stream it's data. To simplify the signalization the application may check if it's safe
+to send it's data by.
+
+    env['thick.async'].ready?
+
+if the method's response is positive it's safe to stream the data.
+
+In the most complex cases it might be necessary to completely bypass default HTTP response generated by the server. In
+those cases the application calls
+
+    env['thick.async'].custom!(*params, &block)
+
+the method informs the server to not send any response on the connection and do not close the connection.
+The contract is the same as with async! mechanism. The block with parameters params is triggered by the server when
+it's safe to stream data. If the block is not given it's completely up to the application to stream the data.
+The application may check whether the server considers safe to stream data by the same way as with async! response
+
+    env['thick.async'].ready?
+
+In the case of custom responses it should be safe to stream right away without checking the server's opinion. Also with
+custom responses it's not necessary to return standard rack response.
+
+## Starting
+
+    thick [-o <interface>] [-p <port>] [-E <environment>]
+
+## Installation
+
+    gem install thick
+
+## License
+
+MIT ... let me know if that's a problem for you.

data/ROADMAP.md

@@ -0,0 +1,12 @@
+## Must to have
+
+* SSL support
+* Tests
+* Code refactorings
+* Optimalizations
+* Replace StringIO
+
+## Nice to have
+
+* SPDY support
+* WebSockets support

data/bin/thick

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require 'optparse'
+
+require 'rubygems'
+require 'rack'
+
+$: << File.expand_path('../../lib', __FILE__)
+require 'thick'
+
+options = {}
+
+OptionParser.new do |opts|
+
+  opts.banner = 'Usage: thick [options]'
+
+  opts.separator ''
+  opts.separator 'Ruby options:'
+
+  opts.separator ''
+  opts.separator 'Rack options:'
+
+  opts.on('-o', '--host HOST', 'listen on HOST (default: 0.0.0.0)') do |host|
+    options[:address] = host
+  end
+
+  opts.on('-p', '--port PORT', 'use PORT (default: 9292)') do |port|
+    options[:port] = Integer(port)
+  end
+
+  opts.on('-E', '--env ENVIRONMENT', 'use ENVIRONMENT for defaults (default: development)') do |e|
+    options[:environment] = e
+  end
+
+end.parse!
+
+options[:address] ||= '0.0.0.0'
+options[:port] ||= 9292
+options[:environment] ||= 'development'
+
+ENV['RACK_ENV'] ||= ENV['RAILS_ENV'] ||= options[:environment]
+
+puts "Loading app #{options.inspect}"
+app = Rack::Builder.parse_file('config.ru')
+
+puts "Starting server"
+Thick.start(app[0], options)

data/lib/thick/async_response.rb

@@ -0,0 +1,53 @@
+module Thick
+
+  class AsyncResponse
+
+    def initialize(context)
+      @context = context
+      @ready = false
+      @custom = false
+      @async = false
+      @block = nil
+      @params = []
+    end
+
+    def call(chunk)
+      @context.channel.write(Thick::Java::ChannelBuffers.copiedBuffer(chunk.to_s, Thick::Java::CharsetUtil::UTF_8))
+    end
+
+    def close
+      @context.channel.write(Thick::Java::ChannelBuffers::EMPTY_BUFFER).addListener(Thick::Java::ChannelFutureListener::CLOSE)
+    end
+
+    def ready!
+      @ready = true
+      @block.call(*@params) if @block
+    end
+
+    def ready?
+      @ready
+    end
+
+    def custom!(*params, &block)
+      @custom = true
+      @block = block
+      @params = params
+    end
+
+    def custom?
+      @custom
+    end
+
+    def async!(*params, &block)
+      @async = true
+      @block = block
+      @params = params
+    end
+
+    def async?
+      @async
+    end
+
+  end
+
+end

data/lib/thick/buffer.rb

@@ -0,0 +1,42 @@
+module Thick
+
+  class Buffer
+
+    def initialize
+      @buffers = []
+      @buffer = nil
+      @io = nil
+    end
+
+    def io
+      @buffer ||= Thick::Java::ChannelBuffers.wrapped_buffer(*@buffers)
+      @io ||= Thick::Java::ChannelBufferInputStream.new(@buffer).to_io.binmode
+    end
+
+    def write(data)
+      raise ArgumentError unless data.kind_of?(Thick::Java::ChannelBuffer)
+      @buffers << data
+      @buffer = nil
+      @io = nil
+    end
+
+    def gets
+      self.io.gets
+    end
+
+    def read(length = nil, buffer = nil)
+      buffer ? self.io.read(length, buffer) : self.io.read(length)
+    end
+
+    def each(&block)
+      self.io.each(&block)
+    end
+
+    def rewind
+      @buffer.reader_index(0) if @buffer
+      @io = nil
+    end
+
+  end
+
+end

data/lib/thick/java.rb

@@ -0,0 +1,41 @@
+module Thick
+  module Java
+
+    java_import 'java.io.RandomAccessFile'
+    java_import 'java.net.InetSocketAddress'
+    java_import 'java.util.concurrent.Executors'
+    java_import 'org.jboss.netty.bootstrap.ServerBootstrap'
+    java_import 'org.jboss.netty.buffer.ChannelBuffer'
+    java_import 'org.jboss.netty.buffer.ChannelBufferInputStream'
+    java_import 'org.jboss.netty.buffer.ChannelBuffers'
+    java_import 'org.jboss.netty.handler.codec.http.DefaultHttpResponse'
+    java_import 'org.jboss.netty.handler.codec.http.HttpContentDecompressor'
+    java_import 'org.jboss.netty.handler.codec.http.HttpHeaders'
+    java_import 'org.jboss.netty.handler.codec.http.HttpChunk'
+    java_import 'org.jboss.netty.handler.codec.http.HttpRequest'
+    java_import 'org.jboss.netty.handler.codec.http.HttpRequestDecoder'
+    java_import 'org.jboss.netty.handler.codec.http.HttpResponseEncoder'
+    java_import 'org.jboss.netty.handler.codec.http.HttpResponseStatus'
+    java_import 'org.jboss.netty.handler.codec.http.HttpVersion'
+    java_import 'org.jboss.netty.handler.codec.http.QueryStringDecoder'
+    java_import 'org.jboss.netty.handler.codec.spdy.SpdyFrameDecoder'
+    java_import 'org.jboss.netty.handler.codec.spdy.SpdyFrameEncoder'
+    java_import 'org.jboss.netty.handler.codec.spdy.SpdySessionHandler'
+    java_import 'org.jboss.netty.handler.execution.ExecutionHandler'
+    java_import 'org.jboss.netty.handler.execution.OrderedMemoryAwareThreadPoolExecutor'
+    java_import 'org.jboss.netty.handler.logging.LoggingHandler'
+    java_import 'org.jboss.netty.handler.stream.ChunkedStream'
+    java_import 'org.jboss.netty.handler.stream.ChunkedWriteHandler'
+    java_import 'org.jboss.netty.channel.DefaultFileRegion'
+    java_import 'org.jboss.netty.channel.ChannelFutureListener'
+    java_import 'org.jboss.netty.channel.ChannelPipelineFactory'
+    java_import 'org.jboss.netty.channel.Channels'
+    java_import 'org.jboss.netty.channel.SimpleChannelUpstreamHandler'
+    java_import 'org.jboss.netty.channel.ChannelUpstreamHandler'
+    java_import 'org.jboss.netty.channel.ChannelDownstreamHandler'
+    java_import 'org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory'
+    java_import 'org.jboss.netty.logging.InternalLogLevel'
+    java_import 'org.jboss.netty.util.CharsetUtil'
+
+  end
+end

data/lib/thick/pipeline_factory.rb

@@ -0,0 +1,70 @@
+module Thick
+
+  class TimeProbe
+
+    include Thick::Java::ChannelUpstreamHandler
+    include Thick::Java::ChannelDownstreamHandler
+
+    def self.setup
+      @total = 0
+      @count = 0
+    end
+
+    def initialize
+      @time = Time.now.to_f
+    end
+
+    TimeProbe.setup
+
+    def self.time(time)
+      @total += time
+      @count += 1
+      if @count % 100 == 0
+        puts "AVG: #{@total / @count}"
+        setup
+      end
+    end
+
+    def handleUpstream(context, event)
+      context.send_upstream(event)
+    end
+
+    def handleDownstream(context, event)
+      if event.respond_to?(:getState)
+        stop = Time.now.to_f - @time
+        self.class.time(stop)
+      end
+      context.send_downstream(event)
+    end
+
+  end
+
+  class PipelineFactory
+
+    include Thick::Java::ChannelPipelineFactory
+
+    def initialize(application)
+      @application = application
+      @executor = Thick::Java::ExecutionHandler.new(Thick::Java::OrderedMemoryAwareThreadPoolExecutor.new(20, 0, 0))
+    end
+
+    def getPipeline
+      pipeline = Thick::Java::Channels.pipeline
+      
+      pipeline.add_last('time_probe', TimeProbe.new)
+
+      pipeline.add_last('http_decoder', Thick::Java::HttpRequestDecoder.new)
+      pipeline.add_last('http_encoder', Thick::Java::HttpResponseEncoder.new)
+
+      pipeline.add_last('decompressor', Thick::Java::HttpContentDecompressor.new)
+
+      pipeline.add_last('executor', @executor)
+
+      pipeline.add_last('handler', ServerHandler.new(@application))
+
+      pipeline
+    end
+
+  end
+
+end

data/lib/thick/server.rb

@@ -0,0 +1,31 @@
+module Thick
+
+  def self.start(application, options)
+    @server = Server.new(application)
+    @server.start(:address => options[:address], :port => options[:port])
+  end
+
+  class Server
+
+    def initialize(application)
+      @factory = Thick::Java::NioServerSocketChannelFactory.new(Thick::Java::Executors.new_cached_thread_pool, Thick::Java::Executors.new_cached_thread_pool)
+      @bootstrap = Thick::Java::ServerBootstrap.new(@factory)
+      @bootstrap.pipeline_factory = PipelineFactory.new(application)
+    end
+
+    def start(options = {})
+      @channel = @bootstrap.bind(Thick::Java::InetSocketAddress.new(options[:address], options[:port]))
+      puts 'Server started'
+      loop do
+        # ToDo: Is this hack needed?
+        sleep(100)
+      end
+    end
+
+    def stop
+      @channel.close
+    end
+
+  end
+
+end

data/lib/thick/server_handler.rb

@@ -0,0 +1,138 @@
+require 'stringio'
+
+module Thick
+
+  class ServerHandler < Thick::Java::SimpleChannelUpstreamHandler
+
+    def initialize(application)
+      super()
+      @application = application
+    end
+
+    def channelConnected(context, event)
+    end
+
+    def messageReceived(context, event)
+      request = event.message
+      case request
+        when Thick::Java::HttpRequest
+          on_request(context, request)
+        when Thick::Java::HttpChunk
+          on_chunk(context, request)
+      end
+    end
+
+    def serve_file(context, file, from = 0, to = nil)
+      raf = Thick::Java::RandomAccessFile.new(file, "r")
+      to ||= File.size(file)
+      region = Thick::Java::DefaultFileRegion.new(raf.channel, from, to)
+      context.channel.write(region)
+    end
+
+    def on_request(context, request)
+
+      # Serve file if exists in public directory
+      file = File.join('public', request.uri)
+      return serve_file(context, file).addListener(Thick::Java::ChannelFutureListener::CLOSE) if !request.uri.index('..') && File.exists?(file) && !File.directory?(file)
+
+      query_string = request.uri.split('?', 2)
+      @env = {
+          # Rack specific
+          'rack.version' => [1,1],
+          'rack.url_scheme' => 'http', # ToDo: support https?
+          'rack.input' => Buffer.new,
+          'rack.errors' => $stdout, # ToDo: Sure about that?
+          'rack.multithread' => true,
+          'rack.multiprocess' => false,
+          'rack.run_once' => false,
+          # HTTP specific
+          'REQUEST_METHOD' => request.get_method.name,
+          'SCRIPT_NAME' => '',
+          'PATH_INFO' => query_string[0],
+          'QUERY_STRING' => if query_string[1] && query_string[1] != '' then "?#{query_string[1]}" else '' end,
+          'SERVER_NAME' => 'localhost', # ToDo: Be more precise!
+          'SERVER_PORT' => '8080', # ToDo: Be more precise!
+          # Thick specific
+          'thick.async' => AsyncResponse.new(context)
+      }
+
+      # Get content length if available
+      length = Thick::Java::HttpHeaders.get_content_length(request)
+      @env['CONTENT_LENGTH'] = length if length > 0
+
+      # Extract headers and normalize it's names
+      request.header_names.each do |name|
+        rack_name = name.gsub('-', '_').upcase
+        rack_name = "HTTP_#{rack_name}" unless %w(CONTENT_TYPE CONTENT_LENGTH).include?(rack_name)
+        @env[rack_name] = request.get_header(name)
+      end
+
+      # Write request content into prepared IO
+      @env['rack.input'].write(request.content)
+
+      # No chunks expected, handle request
+      handle_request(context) unless request.chunked?
+    end
+
+    def on_chunk(context, chunk)
+      # Write request content into prepared IO
+      @env['rack.input'].write(chunk.content)
+
+      # No more chunks expected, handle request
+      handle_request(context) if chunk.last?
+    end
+
+    def handle_request(context)
+      response = @application.call(@env)
+
+      # Let the application make the response as it wants
+      if @env['thick.async'].custom?
+        @env['thick.async'].ready!
+        return
+      end
+
+      # Unpack response
+      status, headers, content = response
+
+      # Create response and set status as requested by application
+      @response = Thick::Java::DefaultHttpResponse.new(Thick::Java::HttpVersion::HTTP_1_1, Thick::Java::HttpResponseStatus.value_of(status.to_i))
+
+      # Set headers as requested by application
+      headers.each do |name, value|
+        Thick::Java::HttpHeaders.set_header(@response, name, value)
+      end
+
+      context.channel.write(@response)
+
+      # Set content as requested by application
+      case
+        when content.respond_to?(:to_path)
+          serve_file(context, content.to_path)
+        else
+          content.each do |chunk|
+            context.channel.write(Thick::Java::ChannelBuffers.copiedBuffer(chunk, Thick::Java::CharsetUtil::UTF_8))
+          end
+      end
+
+      # When content is closable, close it
+      content.close if content.respond_to?(:close)
+
+      # Trigger async handler and marker if async response requested, close connection otherwise
+      if @env['thick.async'].async?
+        @env['thick.async'].ready!
+      else
+        @env['thick.async'].close
+      end
+    end
+
+    def channelClosed(context, event)
+    end
+
+    def exceptionCaught(context, e)
+      puts e.message if e.respond_to?(:message)
+      puts e.backtrace if e.respond_to?(:backtrace)
+    end
+
+  end
+
+end

data/lib/thick/version.rb

@@ -0,0 +1,3 @@
+module Thick
+  VERSION = '0.0.4' unless const_defined?(:VERSION)
+end

data/lib/thick.rb

@@ -0,0 +1,13 @@
+require 'rack'
+
+require 'java'
+
+require File.expand_path('../jars/netty-3.4.0.Alpha2.jar', __FILE__)
+
+require 'thick/java'
+require 'thick/version'
+require 'thick/buffer'
+require 'thick/async_response'
+require 'thick/server_handler'
+require 'thick/pipeline_factory'
+require 'thick/server'

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: thick
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.4
+platform: java
+authors: 
+  - Marek Jelen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-29 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rack
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 1.4.1
+    type: :runtime
+    version_requirements: *id001
+description: Very lightweight web server for JRuby based on Netty library.
+email: 
+  - marek@jelen.biz
+executables: 
+  - thick
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - bin/thick
+  - lib/thick.rb
+  - lib/jars/netty-3.4.0.Alpha2.jar
+  - lib/thick/async_response.rb
+  - lib/thick/buffer.rb
+  - lib/thick/java.rb
+  - lib/thick/pipeline_factory.rb
+  - lib/thick/server.rb
+  - lib/thick/server_handler.rb
+  - lib/thick/version.rb
+  - LICENSE
+  - README.md
+  - ROADMAP.md
+  - CHANGELOG.md
+homepage: http://github.com/marekjelen/thick
+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: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Very lightweight web server for JRuby
+test_files: []
+