New Features : Session Handler and Multipart Parser

Gemfile

@@ -3,6 +3,7 @@ source 'https://rubygems.org'
 gem 'celluloid'
 gem 'celluloid-io'
 gem 'http'
+gem 'multipart-parser', '~> 0.1.1'
 
 gem 'jruby-openssl' if defined? JRUBY_VERSION
 gem 'coveralls', require: false

examples/custom_session.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec ruby examples/custom_session.rb
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+require 'reel/session'
+
+puts "*** Starting server on http://127.0.0.1:4567"
+
+# All Session config parameter are optional (default parameter value will be used)
+session_config1= {:session_length=>86400,:session_name=>'basic',:secret_key=>'secret'} # session_length = 24hr
+Reel::Server::HTTP.new('127.0.0.1', 4567, {:session=>session_config1}) do |connection|
+  connection.each_request do |request|
+    # Session value can access using request.session
+    if request.session[:hi]
+      puts ":hi found in session: '#{request.session[:hi]}'"
+    else
+      request.session[:hi] = 'hello'
+    end
+    request.respond :ok, "hello, world!\n"
+  end
+
+end
+
+puts "*** Starting server on http://127.0.0.1:4568"
+
+# All Session config parameter are optional (default parameter value will be used)
+session_config2 = {:session_length=>300,:session_name=>'basic',:secret_key=>'secret'} # session_length = 5min
+Reel::Server::HTTP.new('127.0.0.1', 4568, {:session=>session_config2}) do |connection|
+  connection.each_request do |request|
+    # Session value can access using request.session
+    if request.session[:bye]
+      puts ":bye found in session: '#{request.session[:bye]}'"
+    else
+      request.session[:bye] = 'bye'
+    end
+    request.respond :ok, "later, world!\n"
+  end
+
+end
+
+sleep

examples/hello_world_multipart.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/hello_world_multipart.rb
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+require 'reel/request/multipart'
+
+addr, port = '127.0.0.1', 1234
+
+puts "*** Starting server on http://#{addr}:#{port}"
+Reel::Server::HTTP.run(addr, port) do |connection|
+  connection.each_request do |request|
+    if request.multipart?
+      request.multipart.each do |key,val|
+        puts File.read(val[:data])
+      end
+      request.respond :ok, "Hello world!! Got multipart post!!"
+    else
+      request.respond 400, "Expecting Multipart Request!!"
+    end
+
+  end
+
+end

examples/hello_world_session.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec examples/hello_world_session.rb
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+require 'reel/session'
+
+addr, port = '127.0.0.1', 1234
+
+puts "*** Starting server with default session config on http://#{addr}:#{port}"
+Reel::Server::HTTP.run(addr, port) do |connection|
+  # For keep-alive support
+  connection.each_request do |request|
+    # Ordinarily we'd route the request here, e.g.
+    # route request.url
+    # Session value can access using request.session
+    if request.session[:user_id]
+      puts "found user: #{request.session[:user_id]}"
+    else
+      request.session[:user_id] = "temp"
+    end
+    # Updated Session value will be stored in store at response
+    request.respond :ok, "hello, world!"
+  end
+
+  # Reel takes care of closing the connection for you
+  # If you would like to hand the connection off to another thread or actor,
+  # use, connection.detach and then manually call connection.close when done
+end

examples/multithreaded_reel_with_session.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# Run with: bundle exec ruby examples/multithreaded_reel_with_session.rb
+
+require 'rubygems'
+require 'bundler/setup'
+require 'reel'
+
+require 'reel/session'
+
+class MyConnectionHandler
+  include Celluloid
+
+  def initialize(connection)
+    @connection = connection
+    async.run
+  rescue Reel::SocketError
+    @connection.close
+  end
+
+  def run
+    @connection.each_request { |req| handle_request(req) }
+  end
+
+  def handle_request(request)
+    # Session value can access using request.session
+    if request.session[:user_id]
+      puts "found user: #{request.session[:user_id]}"
+    else
+      request.session[:user_id] = "temp"
+    end
+    request.respond :ok,"hello world!!"
+  end
+end
+
+# Just adding custom session length of 10 sec
+session_config = {:session_length=>10}
+
+puts "*** Starting server with custom session on http://127.0.0.1:3000"
+Reel::Server::HTTP.new('127.0.0.1', 3000, {:session=>session_config}) do |connection|
+  # We're handing this connection off to another actor, so
+  # we detach it first before handing it off
+  connection.detach
+
+  MyConnectionHandler.new(connection)
+end
+
+puts "*** Starting server with default session on http://127.0.0.1:3001"
+Reel::Server::HTTP.new('127.0.0.1', 3001) do |connection|
+  # We're handing this connection off to another actor, so
+  # we detach it first before handing it off
+  connection.detach
+
+  MyConnectionHandler.new(connection)
+end
+
+sleep

examples/reel_pool_session.rb

@@ -0,0 +1,39 @@
+require 'bundler/setup'
+require 'reel'
+require 'celluloid/autostart'
+
+require 'reel/session'
+
+class MyConnectionHandler
+  include Celluloid
+
+  def handle_connection(connection)
+    connection.each_request { |req| handle_request(req) }
+  rescue Reel::SocketError
+    connection.close
+  end
+
+  def handle_request(request)
+    # Session value can access using request.session
+    if request.session[:user_id]
+      puts "found user: #{request.session[:user_id]}"
+    else
+      request.session[:user_id] = "temp"
+    end
+    request.respond :ok,"hello world!!"
+  end
+end
+
+connectionPool = MyConnectionHandler.pool
+
+# Just adding custom session length of 10 sec
+session_config = {:session_length=>10}
+
+Reel::Server::HTTP.run('127.0.0.1', 1234, {:session=>session_config}) do |connection|
+  # We're handing this connection off to another actor, so
+  # we detach it first before handing it off
+  connection.detach
+
+  # Let a Connection Pool handle the connections for Roflscale Applications
+  connectionPool.async.handle_connection(connection)
+end

lib/reel.rb

@@ -41,4 +41,5 @@ class UnsupportedMethodError < ArgumentError; end
 
   # wrong state for a given operation
   class StateError < RuntimeError; end
+
 end

lib/reel/connection.rb

@@ -16,13 +16,14 @@ class Connection
 
     # Attempt to read this much data
     BUFFER_SIZE = 16384
-    attr_reader :buffer_size
+    attr_reader :buffer_size, :server
 
-    def initialize(socket, buffer_size = nil)
+    def initialize(socket, buffer_size = nil, server = nil)
       @attached    = true
       @socket      = socket
       @keepalive   = true
       @buffer_size = buffer_size || BUFFER_SIZE
+      @server = server
       @parser      = Request::Parser.new(self)
       @request_fsm = Request::StateMachine.new(@socket)
 

lib/reel/request.rb

@@ -14,7 +14,7 @@ class Request
 
     def_delegators :@connection, :remote_addr, :respond
     def_delegator  :@response_writer, :handle_response
-    attr_reader :body
+    attr_reader :body, :connection
 
     # request_info is a RequestInfo object including the headers and
     # the url, method and http version.
@@ -112,7 +112,7 @@ def websocket?; @request_info.websocket_request?; end
     # the underlying connection
     def websocket
       @websocket ||= begin
-        raise StateError, "can't upgrade this request to a websocket" unless websocket?  
+        raise StateError, "can't upgrade this request to a websocket" unless websocket?
         WebSocket.new(self, @connection)
       end
     end

lib/reel/request/multipart.rb

@@ -0,0 +1,96 @@
+require 'multipart_parser/parser'
+require 'multipart_parser/reader'
+require 'tempfile'
+
+module Reel
+  class Request
+    include Celluloid::Internals::Logger
+
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    # if multipart type
+    #   return Hash :
+    #   {
+    #     key1 => {
+    #       :data => Tempfile object,
+    #       :complete => true/false,
+    #       :part => part object (header info etc)
+    #     },
+    #    key2 => {...}
+    #   }
+    # if not multipart type
+    #   return nil
+    def multipart
+      @multipart.decode if multipart?
+    end
+
+    # utility function to check if Content-Type is a multipart type
+    # and initializing @multipart
+    def multipart?
+      return @multipart.is_a? Reel::Request::Multipart if @multipart
+      # extract boundary
+      boundary = extract_boundary self.headers[CONTENT_TYPE]
+      # initializing Multipart
+      @multipart = Reel::Request::Multipart.new @body, boundary if boundary
+      @multipart.is_a? Reel::Request::Multipart
+    rescue => e
+      warn e
+      @multipart = false
+    end
+
+    def extract_boundary(content)
+      MultipartParser::Reader.extract_boundary_value content
+    end
+
+    class Multipart
+      extend Forwardable
+
+      def initialize(body, boundary)
+        @files = {}
+        @body = body
+        @boundary = boundary
+        @reader = MultipartParser::Reader.new(@boundary)
+
+        # configuring MultipartParser::Reader
+        @reader.on_part do |part|
+          # Streaming API So each file blob will contain information
+          # regarding: data,part (for header and other information) and complete
+          if part.filename
+            blob = {:data => Tempfile.new(part.filename), :complete => false, :part => part }
+          else
+            blob = {:data => "", :complete => false, :part => part}
+          end
+          # adding file blob associating it with part.name
+          @files[part.name] = blob
+
+          # registering callback
+          part.on_data { |data_chunk| blob[:data] << data_chunk }
+          part.on_end do
+            blob[:complete] = true
+            blob[:data].rewind if blob[:data].is_a? Tempfile
+            #TODO : expose part information if needed
+
+          end
+        end
+
+        @reader.on_error{|msg| warn msg }
+
+      end
+
+      def_delegators :@reader, :write
+
+      def decode
+        return @files if @files.any?
+        begin
+          @body.each { |chunks| write chunks }
+        rescue => e
+          warn e
+          @files = {}
+        end
+        @files
+      end
+
+    end
+
+  end
+end

lib/reel/request/parser.rb

@@ -55,6 +55,7 @@ def on_headers_complete(headers)
 
         if @currently_reading
           @pending_reads << req
+          req
         else
           @currently_reading = req
         end

lib/reel/server.rb

@@ -44,7 +44,7 @@ def handle_connection(socket)
         socket = Reel::Spy.new(socket, @spy)
       end
 
-      connection = Connection.new(socket)
+      connection = Connection.new(socket, nil, self)
 
       begin
         @callback.call(connection)