thick 0.0.5-java → 0.0.6-java

data/README.md

@@ -20,45 +20,48 @@ Thick provides interfaces to control it's behaviour.
 
 Asynchronous responses provide functionality to stream response to the client by chunks.
 
-The most basic API looks
+To enable streaming, run
 
-    env['thick.async'].async!(*params, &block)
+    env['thick.response'].chunked # For chunked encoded stream
+    env['thick.response'].streamed # For raw stream
 
-the application has to respond in a standard manner
+and define "thick.async" callback in environment, so it reacts to "call" and takes one argument
 
-    [status, headers, body]
+    env['thick.async'] = proc do |response|
+      # do something here
+    end
 
-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
+now simply respond as usual. Once the headers and the basic content is sent, the callback will be invoked.
 
-    env['thick.async'].call(chunk)
+To write content to the stream use
 
-after the response is completed the application has to close the connection
+    response.writeContent("some content")
 
-    env['thick.async'].close
+and do not forget close the stream once done
 
-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.
+    response.close
 
-    env['thick.async'].ready?
+Example using Sinatra
 
-if the method's response is positive it's safe to stream the data.
+    require 'sinatra/base'
 
-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
+    class App < Sinatra::Base
 
-    env['thick.async'].custom!(*params, &block)
+      get '/' do
+        env['thick.async'] = proc do |response|
+          (1..10).each do |i|
+            response.writeContent(i.to_s)
+            sleep(1)
+          end
+          response.close
+        end
+        env['thick.response'].chunked
+        "0"
+      end
 
-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
+    end
 
-    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.
+    run App
 
 ## Starting
 

data/bin/thick

@@ -44,4 +44,4 @@ OptionParser.new do |opts|
 
 end.parse!
 
-Thick.start(options)
+Thick.create(options)

data/lib/thick/java.rb

@@ -1,53 +1,10 @@
 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.DefaultHttpChunk'
-    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.HttpChunkAggregator'
-    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.http.websocketx.CloseWebSocketFrame'
-    java_import 'org.jboss.netty.handler.codec.http.websocketx.PingWebSocketFrame'
-    java_import 'org.jboss.netty.handler.codec.http.websocketx.PongWebSocketFrame'
-    java_import 'org.jboss.netty.handler.codec.http.websocketx.TextWebSocketFrame'
-    java_import 'org.jboss.netty.handler.codec.http.websocketx.WebSocketFrame'
-    java_import 'org.jboss.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory'
-    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'
-    java_import 'org.jruby.CompatVersion'
-    java_import 'org.jruby.embed.AttributeName'
-    java_import 'org.jruby.embed.LocalContextScope'
-    java_import 'org.jruby.embed.ScriptingContainer'
-
+    java_import 'cz.marekjelen.thick.Server'
+    java_import 'cz.marekjelen.thick.ServerEnvironment'
+    java_import 'cz.marekjelen.thick.ServerRubyInterface'
+    java_import 'io.netty.buffer.Unpooled'
+    java_import 'io.netty.buffer.ByteBufInputStream'
   end
 end

data/lib/thick/loader.rb

@@ -2,6 +2,8 @@ module Thick
 
   class Loader
 
+    include Thick::Java::ServerRubyInterface
+
     def initialize(options)
       @options = options
       ENV['RACK_ENV'] ||= ENV['RAILS_ENV'] ||= @options[:environment]
@@ -9,7 +11,26 @@ module Thick
     end
 
     def call(env)
-      @application.call(env)
+      env['rack.input'] = env['rack.input'].to_io
+      env['rack.errors'] = env['rack.errors'].to_io
+
+      status, headers, body = @application.call(env)
+
+      response = env['thick.response']
+
+      response.setStatus(status)
+
+      headers.each_pair do |name, value|
+        response.setHeader(name, value)
+      end
+
+      if body.respond_to?(:to_path)
+        response.send_file(body.to_path)
+      else
+        body.each { |chunk| response.writeContent(chunk.to_s) }
+        response.send
+        env['thick.async'].call(response) if response.chunked?
+      end
     rescue => e
       puts e.message
       puts e.backtrace

data/lib/thick/thick.rb

@@ -1,29 +1,23 @@
 module Thick
 
-  def self.start(options)
-    @options = {
+  def self.create(options)
+    options = {
         :address => '0.0.0.0',
         :port => 9292,
         :environment => 'development',
-        :reloader => false,
-        :controller => false,
         :directory => Dir.getwd,
         :file => 'config.ru'
     }.merge(options)
 
-    puts "* Starting Thick: #{@options.inspect}"
+    puts "* Starting Thick: #{options.inspect}"
 
-    @options[:application] = Loader.new(@options)
-    @server = Server.new(@options).start
+    env = Thick::Java::ServerEnvironment.new
+    env.address = options[:address]
+    env.port = options[:port]
 
-    if @options[:controller]
-      @controller = Controller.new(@options, @server)
-      @controller.start
-    end
+    env.application = Loader.new(options)
+    Thick::Java::Server.new(env).start
 
-    loop do
-      sleep(100) # ToDo: Is this hack needed?
-    end
   end
 
 end

data/lib/thick/version.rb

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

data/lib/thick.rb

@@ -2,16 +2,10 @@ require 'rack'
 
 require 'java'
 
-require File.expand_path('../jars/netty-3.5.11.Final.jar', __FILE__)
+require File.expand_path('../jars/netty-4.0.0.Alpha7.jar', __FILE__)
+require File.expand_path('../jars/thick-0.0.1.jar', __FILE__)
 
 require 'thick/java'
-require 'thick/thick'
 require 'thick/version'
-require 'thick/buffer'
-require 'thick/async_response'
-require 'thick/loader'
-require 'thick/server_handler'
-require 'thick/pipeline_factory'
-require 'thick/controller'
-require 'thick/server'
-
+require 'thick/thick'
+require 'thick/loader'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thick
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease:
 platform: java
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2012-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -55,8 +55,6 @@ files:
   YmluL3RoaWNr
 - !binary |-
   bGliL3RoaWNrLnJi
-- !binary |-
-  bGliL3RoaWNrL3BpcGVsaW5lX2ZhY3RvcnkucmI=
 - !binary |-
   bGliL3RoaWNrL2phdmEucmI=
 - !binary |-
@@ -66,17 +64,9 @@ files:
 - !binary |-
   bGliL3RoaWNrL3ZlcnNpb24ucmI=
 - !binary |-
-  bGliL3RoaWNrL3NlcnZlcl9oYW5kbGVyLnJi
-- !binary |-
-  bGliL3RoaWNrL2FzeW5jX3Jlc3BvbnNlLnJi
-- !binary |-
-  bGliL3RoaWNrL2J1ZmZlci5yYg==
-- !binary |-
-  bGliL3RoaWNrL2NvbnRyb2xsZXIucmI=
-- !binary |-
-  bGliL3RoaWNrL3NlcnZlci5yYg==
+  bGliL2phcnMvbmV0dHktNC4wLjAuQWxwaGE3Lmphcg==
 - !binary |-
-  bGliL2phcnMvbmV0dHktMy41LjExLkZpbmFsLmphcg==
+  bGliL2phcnMvdGhpY2stMC4wLjEuamFy
 - LICENSE
 - README.md
 - ROADMAP.md

data/lib/thick/async_response.rb

@@ -1,88 +0,0 @@
-module Thick
-
-  class AsyncResponse
-
-    def initialize(context)
-      @context = context
-      @ready = false
-      @custom = false
-      @async = false
-      @block = nil
-      @chunked = false
-      @content_length = nil
-      @closed = false
-      @params = []
-    end
-
-    def call(chunk)
-      chunk = Thick::Java::ChannelBuffers.copiedBuffer(chunk.to_s, Thick::Java::CharsetUtil::UTF_8)
-      chunk = Thick::Java::DefaultHttpChunk.new(chunk) if @chunked
-      @context.channel.write(chunk) unless closed?
-    end
-
-    def close
-      if @chunked
-        chunk = Thick::Java::ChannelBuffers.copiedBuffer("0\r\n\r\n", Thick::Java::CharsetUtil::UTF_8)
-      else
-        chunk = Thick::Java::ChannelBuffers::EMPTY_BUFFER
-      end
-      @context.channel.write(chunk).addListener(Thick::Java::ChannelFutureListener::CLOSE) unless closed?
-      closed!
-    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
-
-    def chunked!
-      @chunked = true
-    end
-
-    def chunked?
-      @chunked
-    end
-
-    def content_length!(length)
-      @content_length = length
-    end
-
-    def content_length
-      @content_length
-    end
-
-    def closed!
-      @closed = true
-    end
-
-    def closed?
-      @closed
-    end
-
-  end
-
-end

data/lib/thick/buffer.rb

@@ -1,42 +0,0 @@
-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/controller.rb

@@ -1,88 +0,0 @@
-module Thick
-  class Controller
-
-    def initialize(options, server)
-      @options = options
-      @server = server
-      @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 = Controller::PipelineFactory.new(@options)
-    end
-
-    def start
-      @channel = @bootstrap.bind(Thick::Java::InetSocketAddress.new('127.0.0.1', 9393))
-      puts "* Controller started on 127.0.0.1:9393"
-      self
-    end
-
-    def stop
-      @channel.close
-      self
-    end
-
-    class PipelineFactory
-
-      include Thick::Java::ChannelPipelineFactory
-
-      def initialize(options)
-        @options = options
-      end
-
-      def getPipeline
-        pipeline = Thick::Java::Channels.pipeline
-        pipeline.add_last('decoder', Thick::Java::HttpRequestDecoder.new)
-        pipeline.add_last('aggregator', Thick::Java::HttpChunkAggregator.new(65536))
-        pipeline.add_last('encoder', Thick::Java::HttpResponseEncoder.new)
-        pipeline.add_last('handler', Controller::Handler.new(@options))
-        pipeline
-      end
-
-    end
-
-    class Handler < Thick::Java::SimpleChannelUpstreamHandler
-
-      def messageReceived(context, event)
-        message = event.message
-        case message
-          when Thick::Java::HttpRequest
-            handle_request(context, message)
-          when Thick::Java::WebSocketFrame
-            handle_websocket_frame(context, message)
-        end
-      end
-
-      def handle_request(context, request)
-        url = "ws://" + request.get_header(Thick::Java::HttpHeaders::Names::HOST) + '/controller'
-        factory = Thick::Java::WebSocketServerHandshakerFactory.new(url, nil, false)
-        @handshaker = factory.new_handshaker(request)
-        if @handshaker
-          @handshaker.handshake(context, request)
-        else
-          factory.send_unsupported_webSocket_version_response(context)
-        end
-      end
-
-      def handle_websocket_frame(context, frame)
-        case frame
-          when Thick::Java::CloseWebSocketFrame
-            @handshaker.close(context, frame)
-          when Thick::Java::PingWebSocketFrame
-            context.channel.write(Thick::Java::PongWebSocketFrame.new(frame.binary_data))
-          when Thick::Java::TextWebSocketFrame
-            handle_websocket_message(context, frame.text)
-        end
-      end
-
-      def websocket_send(context, message)
-        context.channel.write(Thick::Java::TextWebSocketFrame.new(message.to_s))
-      end
-
-      def handle_websocket_message(context, message)
-
-      end
-
-    end
-
-  end
-
-end

data/lib/thick/pipeline_factory.rb

@@ -1,29 +0,0 @@
-module Thick
-
-  class PipelineFactory
-
-    include Thick::Java::ChannelPipelineFactory
-
-    def initialize(options)
-      @options = options
-      @executor = Thick::Java::ExecutionHandler.new(Thick::Java::OrderedMemoryAwareThreadPoolExecutor.new(20, 0, 0))
-    end
-
-    def getPipeline
-      pipeline = Thick::Java::Channels.pipeline
-
-      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(@options))
-
-      pipeline
-    end
-
-  end
-
-end

data/lib/thick/server.rb

@@ -1,25 +0,0 @@
-module Thick
-
-  class Server
-
-    def initialize(options)
-      @options = options
-      @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(@options)
-    end
-
-    def start
-      @channel = @bootstrap.bind(Thick::Java::InetSocketAddress.new(@options[:address], @options[:port]))
-      puts "* Server started on #{@options[:address]}:#{@options[:port]}"
-      self
-    end
-
-    def stop
-      @channel.close
-      self
-    end
-
-  end
-
-end

data/lib/thick/server_handler.rb

@@ -1,147 +0,0 @@
-module Thick
-
-  class ServerHandler < Thick::Java::SimpleChannelUpstreamHandler
-
-    def initialize(options)
-      super()
-      @options = options
-    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(@options[:directory], '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),
-          'thick.options' => @options
-      }
-
-      # 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 = @options[: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
-
-      if @env['thick.async'].async?
-        if length = @env['thick.async'].content_length
-          Thick::Java::HttpHeaders.set_content_length(@response, length)
-        else
-          @response.remove_header('Content-Length')
-        end
-        @response.chunked = true if @env['thick.async'].chunked?
-      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)
-      @env['thick.async'].closed!
-    end
-
-    def exceptionCaught(context, e)
-      puts e.message if e.respond_to?(:message)
-      puts e.backtrace if e.respond_to?(:backtrace)
-    end
-
-  end
-
-end