net-http-server 0.1.0

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.*
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "net-http-server Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,8 @@
+### 0.1.0 / 2011-01-26
+
+* Initial release:
+  * Added {Net::HTTP::Server::Parser}.
+  * Added {Net::HTTP::Server::Requests}.
+  * Added {Net::HTTP::Server::Responses}.
+  * Added {Net::HTTP::Server::Daemon}.
+  * Added {Rack::Handler::HTTP}.

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Hal Brodigan
+
+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,48 @@
+# net-http-server
+
+* [Homepage](http://github.com/postmodern/net-http-server)
+* [Issues](http://github.com/postmodern/net-http-server/issues)
+* [Documentation](http://rubydoc.info/gems/net-http-server)
+* Postmodern (postmodern.mod3 at gmail.com)
+
+## Description
+
+{Net::HTTP::Server} is a pure Ruby HTTP server.
+
+## Features
+
+* Pure Ruby.
+* Provides a [Rack](http://rack.rubyforge.org/) Handler.
+
+## Examples
+
+Simple HTTP Server:
+
+    require 'net/http/server'
+    require 'pp'
+
+    Net::HTTP::Server.run(:port => 8080) do |request,socket|
+      pp request
+
+      [200, {'Content-Type' => 'text/html'}, ['Hello World']]
+    end
+
+Use it with Rack:
+
+    require 'rack/handler/http'
+    
+    Rack::Handler::HTTP.run app
+
+## Requirements
+
+* [parslet](http://rubygems.org/gems/parslet) ~> 1.0
+
+## Install
+
+    $ gem install net-http-server
+
+## Copyright
+
+Copyright (c) 2011 Hal Brodigan
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'ore-tasks', '~> 0.3.0'
+  require 'ore/tasks'
+
+  Ore::Tasks.new
+rescue LoadError => e
+  STDERR.puts e.message
+  STDERR.puts "Run `gem install ore-tasks` to install 'ore/tasks'."
+end
+
+begin
+  gem 'rspec', '~> 2.4.0'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+task :test => :spec
+task :default => :spec
+
+begin
+  gem 'yard', '~> 0.6.0'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end

data/gemspec.yml

@@ -0,0 +1,16 @@
+name: net-http-server
+summary: A pure Ruby HTTP Server
+description: A Rack compatible pure Ruby HTTP Server.
+license: MIT
+authors: Postmodern
+email: postmodern.mod3@gmail.com
+homepage: http://github.com/postmodern/net-http-server
+has_yard: true
+
+dependencies:
+  parslet: ~> 1.0
+
+development_dependencies:
+  ore-tasks: ~> 0.3.0
+  rspec: ~> 2.4.0
+  yard: ~> 0.6.0

data/lib/net/http/server.rb

@@ -0,0 +1,4 @@
+require 'net/http/server/parser'
+require 'net/http/server/daemon'
+require 'net/http/server/server'
+require 'net/http/server/version'

data/lib/net/http/server/daemon.rb

@@ -0,0 +1,123 @@
+require 'net/http/server/parser'
+require 'net/http/server/requests'
+require 'net/http/server/responses'
+
+require 'net/protocol'
+require 'gserver'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      class Daemon < GServer
+
+        include Requests
+        include Responses
+
+        # Default host to bind to.
+        DEFAULT_HOST = '0.0.0.0'
+
+        # Default port to listen on.
+        DEFAULT_PORT = 8080
+
+        # Maximum number of simultaneous connections.
+        MAX_CONNECTIONS = 256
+
+        # Creates a new HTTP Daemon.
+        #
+        # @param [Hash] options
+        #   Options for the daemon.
+        #
+        # @option options [String] :host (DEFAULT_HOST)
+        #   The host to run on.
+        #
+        # @option options [String] :port (DEFAULT_PORT)
+        #   The port to listen on.
+        #
+        # @option options [Integer] :max_connections (MAX_CONNECTIONS)
+        #   The maximum number of simultaneous connections.
+        #
+        # @option options [IO] :log (STDERR)
+        #   The log to write errors to.
+        #
+        # @option options [#call] :handler
+        #   The HTTP Request Handler object.
+        #
+        # @yield [request, socket]
+        #   If a block is given, it will be used to process HTTP Requests.
+        #
+        # @yieldparam [Hash{Symbol => String,Array,Hash}] request
+        #   The HTTP Request.
+        #
+        # @yieldparam [TCPSocket] socket
+        #   The TCP socket of the client.
+        #
+        def initialize(options={},&block)
+          host = options.fetch(:host,DEFAULT_HOST)
+          port = options.fetch(:port,DEFAULT_PORT).to_i
+          max_connections = options.fetch(:max_connections,MAX_CONNECTIONS)
+          log = options.fetch(:log,STDERR)
+
+          super(port,host,max_connections,log,false,true)
+
+          handler(options[:handler],&block)
+        end
+
+        #
+        # Sets the HTTP Request Handler.
+        #
+        # @param [#call, nil] object
+        #   The HTTP Request Handler object.
+        #
+        # @yield [request, socket]
+        #   If a block is given, it will be used to process HTTP Requests.
+        #
+        # @yieldparam [Hash{Symbol => String,Array,Hash}] request
+        #   The HTTP Request.
+        #
+        # @yieldparam [TCPSocket] socket
+        #   The TCP socket of the client.
+        #
+        # @raise [ArgumentError]
+        #   The HTTP Request Handler must respond to `#call`.
+        #
+        def handler(object=nil,&block)
+          if object
+            unless object.respond_to?(:call)
+              raise(ArgumentError,"HTTP Request Handler must respond to #call")
+            end
+          elsif block.nil?
+            raise(ArgumentError,"no HTTP Request Handler block given")
+          end
+
+          @handler = (object || block)
+        end
+
+        #
+        # Receives HTTP Requests and handles them.
+        #
+        # @param [TCPSocket] socket
+        #   A new TCP connection.
+        #
+        def serve(socket)
+          if (raw_request = read_request(socket))
+            parser = Parser.new
+
+            begin
+              request = parser.parse(raw_request)
+            rescue Parslet::ParseFailed => error
+              return Responses::BAD_REQUEST
+            end
+
+            normalize_request(request)
+
+            # rack compliant
+            status, headers, body = @handler.call(request,socket)
+
+            write_response(socket,status,headers,body)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/net/http/server/parser.rb

@@ -0,0 +1,151 @@
+require 'net/protocol'
+require 'parslet'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      #
+      # Inspired by:
+      #
+      # * [Thin](https://github.com/macournoyer/thin/blob/master/ext/thin_parser/common.rl)
+      # * [Unicorn](https://github.com/defunkt/unicorn/blob/master/ext/unicorn_http/unicorn_http_common.rl)
+      # * [RFC 2616](http://www.w3.org/Protocols/rfc2616/rfc2616.html)
+      #
+      class Parser < Parslet::Parser
+
+        #
+        # Character Classes
+        #
+        rule(:digit) { match['0-9'] }
+        rule(:digits) { digit.repeat(1) }
+        rule(:xdigit) { digit | match['a-fA-F'] }
+        rule(:upper) { match['A-Z'] }
+        rule(:lower) { match['a-z'] }
+        rule(:alpha) { upper | lower }
+        rule(:alnum) { alpha | digit }
+        rule(:cntrl) { match['\x00-\x1f'] }
+        rule(:ascii) { match['\x00-\x7f'] }
+
+        rule(:lws) { match[" \t"] }
+        rule(:crlf) { str("\r\n") }
+
+        rule(:ctl) { cntrl | str("\x7f") }
+        rule(:text) { lws | (ctl.absnt? >> ascii) }
+
+        rule(:safe) { charset('$', '-', '_', '.') }
+        rule(:extra) { charset('!', '*', "'", '(', ')', ',') }
+        rule(:reserved) { charset(';', '/', '?', ':', '@', '&', '=', '+') }
+        rule(:sorta_safe) { charset('"', '<', '>') }
+
+        rule(:unsafe) { ctl | charset(' ', '#', '%') | sorta_safe }
+        rule(:national) {
+          (alpha | digit | reserved | extra | safe | unsafe).absnt? >> any
+        }
+
+        rule(:unreserved) { alpha | digit | safe | extra | national }
+        rule(:escape) { str("%u").maybe >> xdigit >> xdigit }
+        rule(:uchar) { unreserved | escape | sorta_safe }
+        rule(:pchar) { uchar | charset(':', '@', '&', '=', '+') }
+        rule(:separators) {
+          lws | charset(
+            '(', ')', '<', '>', '@', ',', ';', ':', "\\", '"', '/', '[', ']',
+            '?', '=', '{', '}'
+          )
+        }
+
+        #
+        # Elements
+        #
+        rule(:token) { (ctl | separators).absnt? >> ascii }
+
+        rule(:comment_text) { (str('(') | str(')')).absnt? >> text }
+        rule(:comment) { str('(') >> comment_text.repeat >> str(')') }
+
+        rule(:quoted_pair) { str("\\") >> ascii }
+        rule(:quoted_text) { quoted_pair | str('"').absnt? >> text }
+        rule(:quoted_string) { str('"') >> quoted_text >> str('"') }
+
+        #
+        # URI Elements
+        #
+        rule(:scheme) {
+          (alpha | digit | charset('+', '-', '.')).repeat
+        }
+        rule(:host_name) {
+          (alnum | charset('-', '_', '.')).repeat(1)
+        }
+        rule(:user_info) {
+          (
+            unreserved | escape | charset(';', ':', '&', '=', '+')
+          ).repeat(1)
+        }
+
+        rule(:path) { pchar.repeat(1) >> (str('/') >> pchar.repeat).repeat }
+        rule(:query_string) { (uchar | reserved).repeat }
+        rule(:param) { (pchar | str('/')).repeat }
+        rule(:params) { param >> (str(';') >> param).repeat }
+        rule(:frag) { (uchar | reserved).repeat }
+
+        rule(:relative_path) {
+          path.maybe.as(:path) >>
+          (str(';') >> params.as(:params)).maybe >>
+          (str('?') >> query_string.as(:query)).maybe >>
+          (str('#') >> frag.as(:fragment)).maybe
+        }
+        rule(:absolute_path) { str('/').repeat(1) >> relative_path }
+
+        rule(:absolute_uri) {
+          scheme.as(:scheme) >> str(':') >> str('//').maybe >>
+          (user_info.as(:user_info) >> str('@')).maybe >>
+          host_name.as(:host) >>
+          (str(':') >> digits.as(:port)).maybe >>
+          absolute_path
+        }
+
+        rule(:request_uri) { str('*') | absolute_uri | absolute_path }
+
+        #
+        # HTTP Elements
+        #
+        rule(:request_method) { upper.repeat(1,20) | token.repeat(1) }
+
+        rule(:version_number) { digits >> str('.') >> digits }
+        rule(:http_version) { str('HTTP/') >> version_number.as(:version) }
+        rule(:request_line) {
+          request_method.as(:method) >>
+          str(' ') >> request_uri.as(:uri) >>
+          str(' ') >> http_version
+        }
+
+        rule(:header_name) { (str(':').absnt? >> token).repeat(1) }
+        rule(:header_value) {
+          (text | token | separators | quoted_string).repeat(1)
+        }
+
+        rule(:header) {
+          header_name.as(:name) >> str(':') >> lws.repeat(1) >>
+          header_value.as(:value) >> crlf
+        }
+        rule(:request) {
+          request_line >> crlf >>
+          header.repeat.as(:headers) >> crlf
+        }
+
+        root :request
+
+        protected
+
+        #
+        # Creates a matcher for the given characters.
+        #
+        # @param [Array<String>] chars
+        #   The characters to match.
+        #
+        def charset(*chars)
+          match[chars.map { |c| Regexp.escape(c) }.join]
+        end
+
+      end
+    end
+  end
+end

data/lib/net/http/server/requests.rb

@@ -0,0 +1,129 @@
+require 'net/protocol'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      module Requests
+        # Default ports for common URI schemes
+        DEFAULT_PORTS = {
+          'https' => 443,
+          'http' => 80
+        }
+
+        protected
+
+        #
+        # Reads a HTTP Request from the stream.
+        #
+        # @param [IO] stream
+        #   The stream to read from.
+        #
+        # @return [String, nil]
+        #   The raw HTTP Request or `nil` if the Request was malformed.
+        #
+        def read_request(stream)
+          buffer = ''
+
+          request_line = stream.readline("\r\n")
+
+          # the request line must contain 'HTTP/'
+          return unless request_line.include?('HTTP/')
+
+          buffer << request_line
+
+          stream.each_line("\r\n") do |header|
+            buffer << header
+
+            # a header line must contain a ':' character followed by
+            # linear-white-space (either ' ' or "\t").
+            unless (header.include?(': ') || header.include?(":\t"))
+              # if this is not a header line, check if it is the end
+              # of the request
+              if header == "\r\n"
+                # end of the request
+                break
+              else
+                # invalid header line
+                return
+              end
+            end
+          end
+
+          return buffer
+        end
+
+        #
+        # Normalizes the `:uri` part of the request.
+        #
+        # @param [Hash] request
+        #   The unnormalized HTTP request.
+        #
+        def normalize_uri(request)
+          uri = request[:uri]
+
+          if uri.kind_of?(Hash)
+            if uri[:scheme]
+              uri[:port] = unless uri[:port]
+                             DEFAULT_PORTS[uri[:scheme]]
+                           else
+                             uri[:port].to_i
+                           end
+            end
+
+            unless uri[:path]
+              uri[:path] = '/'
+            else
+              uri[:path].insert(0,'/')
+            end
+          elsif uri == '*'
+            request[:uri] = {}
+          end
+        end
+
+        #
+        # Normalizes the `:headers` part of the request.
+        #
+        # @param [Hash] request
+        #   The unnormalized HTTP request.
+        #
+        def normalize_headers(request)
+          headers = request[:headers]
+          normalized_headers = {}
+
+          unless headers.empty?
+            headers.each do |header|
+              name = header[:name]
+              value = header[:value]
+
+              if normalized_headers.has_key?(name)
+                previous_value = normalized_headers[name]
+
+                if previous_value.kind_of?(Array)
+                  previous_value << value
+                else
+                  normalized_headers[name] = [previous_value, value]
+                end
+              else
+                normalized_headers[name] = value
+              end
+            end
+          end
+
+          request[:headers] = normalized_headers
+        end
+
+        #
+        # Normalizes a HTTP request.
+        #
+        # @param [Hash] request
+        #   The unnormalized HTTP request.
+        #
+        def normalize_request(request)
+          normalize_uri(request)
+          normalize_headers(request)
+        end
+
+      end
+    end
+  end
+end