net-http-server 0.1.0

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

@@ -0,0 +1,151 @@
+require 'net/protocol'
+require 'time'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      module Responses
+        # The supported HTTP Protocol.
+        HTTP_VERSION = '1.1'
+
+        # The known HTTP Status codes and messages
+        HTTP_STATUSES = {
+          # 1xx
+          100 => 'Continue',
+          101 => 'Switching Protocols',
+          102 => 'Processing',
+          # 2xx
+          200 => 'OK',
+          201 => 'Created',
+          202 => 'Accepted',
+          203 => 'Non-Authoritative Information',
+          204 => 'No Content',
+          205 => 'Reset Content',
+          206 => 'Partial Content',
+          # 3xx
+          300 => 'Multiple Choices',
+          301 => 'Moved Permanently',
+          302 => 'Found',
+          303 => 'See Other',
+          304 => 'Not Modified',
+          305 => 'Use Proxy',
+          307 => 'Temporary Redirect',
+          # 4xx
+          400 => 'Bad Request',
+          401 => 'Unauthorized',
+          402 => 'Payment Required',
+          403 => 'Forbidden',
+          404 => 'Not Found',
+          405 => 'Method Not Allowed',
+          406 => 'Not Acceptable',
+          407 => 'Proxy Authentication Required',
+          408 => 'Request Time-out',
+          409 => 'Conflict',
+          410 => 'Gone',
+          411 => 'Length Required',
+          412 => 'Precondition Failed',
+          413 => 'Request Entity Too Large',
+          414 => 'Request-URI Too Large',
+          415 => 'Unsupported Media Type',
+          416 => 'Requested range not satisfiable',
+          417 => 'Expectation Failed',
+          # 5xx
+          500 => 'Internal Server Error',
+          501 => 'Not Implemented',
+          502 => 'Bad Gateway',
+          503 => 'Service Unavailable',
+          504 => 'Gateway Time-out',
+          505 => 'HTTP Version not supported extension-code'
+        }
+
+        # Generic Bad Request response
+        BAD_REQUEST = [400, {}, ['Bad Request']]
+
+        protected
+
+        #
+        # Writes the status of an HTTP Response to a stream.
+        #
+        # @param [IO] stream
+        #   The stream to write the headers back to.
+        #
+        # @param [Integer] status
+        #   The status of the HTTP Response.
+        #
+        def write_status(stream,status)
+          status = status.to_i
+
+          reason = HTTP_STATUSES[status]
+          stream.write("HTTP/#{HTTP_VERSION} #{status} #{reason}\r\n")
+        end
+
+        #
+        # Write the headers of an HTTP Response to a stream.
+        #
+        # @param [IO] stream
+        #   The stream to write the headers back to.
+        #
+        # @param [Hash{String => [String, Time, Array<String>}] headers
+        #   The headers of the HTTP Response.
+        #
+        def write_headers(stream,headers)
+          headers.each do |name,values|
+            case values
+            when String
+              values.each_line("\n") do |value|
+                stream.write("#{name}: #{value.chomp}\r\n")
+              end
+            when Time
+              stream.write("#{name}: #{values.httpdate}\r\n")
+            when Array
+              values.each do |value|
+                stream.write("#{name}: #{value}\r\n")
+              end
+            end
+          end
+
+          stream.write("\r\n")
+          stream.flush
+        end
+
+        #
+        # Writes the body of a HTTP Response to a stream.
+        #
+        # @param [IO] stream
+        #   The stream to write the headers back to.
+        #
+        # @param [#each] body
+        #   The body of the HTTP Response.
+        #
+        def write_body(stream,body)
+          body.each do |chunk|
+            stream.write(chunk)
+            stream.flush
+          end
+        end
+
+        #
+        # Writes a HTTP Response to a stream.
+        #
+        # @param [IO] stream
+        #   The stream to write the HTTP Response to.
+        #
+        # @param [Integer] status
+        #   The status of the HTTP Response.
+        #
+        # @param [Hash{String => [String, Time, Array<String>}] headers
+        #   The headers of the HTTP Response.
+        #
+        # @param [#each] body
+        #   The body of the HTTP Response.
+        #
+        def write_response(stream,status,headers,body)
+          write_status stream, status
+          write_headers stream, headers
+          write_body stream, body
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'net/http/server/daemon'
+
+require 'net/protocol'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      #
+      # Starts the HTTP Server.
+      #
+      # @param [Hash] options
+      #   Options for the server.
+      #
+      # @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 [Boolean] :background (false)
+      #   Specifies whether to run the server in the background or
+      #   foreground.
+      #
+      # @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 Server.run(options={},&block)
+        daemon = Daemon.new(options,&block)
+
+        daemon.start
+        daemon.join unless options[:background]
+        return daemon
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'net/protocol'
+
+module Net
+  class HTTP < Protocol
+    module Server
+      # net-http-server version.
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/rack/handler/http.rb

@@ -0,0 +1,170 @@
+require 'net/http/server/daemon'
+require 'net/http/server/version'
+
+require 'rack'
+require 'set'
+
+module Rack
+  module Handler
+    #
+    # A Rack handler for {Net::HTTP::Server}.
+    #
+    class HTTP
+
+      # The default environment settings.
+      DEFAULT_ENV = {
+        'rack.version' => Rack::VERSION,
+        'rack.errors' => STDERR,
+        'rack.multithread' => true,
+        'rack.multiprocess' => false,
+        'rack.run_once' => false,
+        'rack.url_scheme' => 'http',
+
+        'SERVER_SOFTWARE' => "Net::HTTP::Server/#{Net::HTTP::Server::VERSION} (Ruby/#{RUBY_VERSION}/#{RUBY_RELEASE_DATE})",
+        'SCRIPT_NAME' => ''
+      }
+
+      # Special HTTP Headers used by Rack::Request
+      SPECIAL_HEADERS = Set[
+        'Content-Type',
+        'Content-Length',
+      ]
+
+      #
+      # Initializes the handler.
+      #
+      # @param [#call] app
+      #   The application the handler will be passing requests to.
+      #
+      # @param [Hash] options
+      #   Additional options.
+      #
+      # @option options [String] :Host
+      #   The host to bind to.
+      #
+      # @option options [Integer] :Port
+      #   The port to listen on.
+      #
+      def initialize(app,options={})
+        @app = app
+        @options = options
+
+        @server = nil
+      end
+
+      #
+      # Creates a new handler and begins handling HTTP Requests.
+      #
+      # @see #initialize
+      #
+      def self.run(app,options={})
+        new(app,options).run
+      end
+
+      #
+      # Starts {Net::HTTP::Server} and begins handling HTTP Requests.
+      #
+      def run
+        @server = Net::HTTP::Server::Daemon.new(
+          :host => @options[:Host],
+          :port => @options[:Port],
+          :handler => self
+        )
+
+        @server.start
+        @server.join
+      end
+
+      #
+      # Handles an HTTP Request.
+      #
+      # @param [Hash] request
+      #   An HTTP Request received from {Net::HTTP::Server}.
+      #
+      # @param [TCPSocket] socket
+      #   The socket that the request was received from.
+      #
+      # @return [Array<Integer, Hash, Array>]
+      #   The response status, headers and body.
+      #
+      def call(request,socket)
+        request_uri = request[:uri]
+        remote_address = socket.remote_address
+        local_address = socket.local_address
+
+        env = {}
+
+        # add the default values
+        env.merge!(DEFAULT_ENV)
+
+        # populate
+        env['rack.input'] = socket
+
+        if request_uri[:scheme]
+          env['rack.url_scheme'] = request_uri[:scheme]
+        end
+
+        env['SERVER_NAME'] = local_address.getnameinfo[0]
+        env['SERVER_PORT'] = local_address.ip_port.to_s
+        env['SERVER_PROTOCOL'] = "HTTP/#{request[:http_version]}"
+
+        env['REMOTE_ADDR'] = remote_address.ip_address
+        env['REMOTE_PORT'] = remote_address.ip_port.to_s
+
+        env['REQUEST_METHOD'] = request[:method]
+        env['PATH_INFO'] = request_uri.fetch(:path,'*')
+        env['QUERY_STRING'] = request_uri[:query_string].to_s
+
+        # add the headers
+        request[:headers].each do |name,value|
+          key = name.dup
+          
+          key.upcase!
+          key.tr!('-','_')
+
+          # if the header is not special, prepend 'HTTP_'
+          unless SPECIAL_HEADERS.include?(name)
+            key.insert(0,'HTTP_')
+          end
+
+          env[key] = case value
+                     when Array
+                       value.join("\n")
+                     else
+                       value.to_s
+                     end
+        end
+
+        @app.call(env)
+      end
+
+      #
+      # Determines if the handler is running.
+      #
+      # @return [Boolean]
+      #   Specifies whether the handler is still running.
+      #
+      def running?
+        @server && !(@server.stopped?)
+      end
+
+      #
+      # Determines whether the handler was stopped.
+      #
+      # @return [Boolean]
+      #   Specifies whether the handler was previously stopped.
+      #
+      def stopped?
+        @server.nil? || @server.stopped?
+      end
+
+      #
+      # Stops the handler.
+      #
+      def stop
+        @server.stop if @server
+      end
+
+    end
+  end
+end

data/net-http-server.gemspec

@@ -0,0 +1,10 @@
+# -*- encoding: utf-8 -*-
+
+begin
+  Ore::Specification.new do |gemspec|
+    # custom logic here
+  end
+rescue NameError
+  STDERR.puts "The 'net-http-server.gemspec' file requires Ore."
+  STDERR.puts "Run `gem install ore-core` to install Ore."
+end

data/spec/rack/handler/helpers/test_request.rb

@@ -0,0 +1,69 @@
+require 'net/http'
+require 'yaml'
+
+# Borrowed from Rack's own specs.
+class TestRequest
+  def call(env)
+    status = env["QUERY_STRING"] =~ /secret/ ? 403 : 200
+    env["test.postdata"] = env["rack.input"].read
+    body = env.to_yaml
+    size = body.respond_to?(:bytesize) ? body.bytesize : body.size
+    [status, {"Content-Type" => "text/yaml", "Content-Length" => size.to_s}, [body]]
+  end
+
+  module Helpers
+    attr_reader :status, :response
+
+    ROOT = File.expand_path(File.dirname(__FILE__) + "/..")
+    ENV["RUBYOPT"] = "-I#{ROOT}/lib -rubygems"
+
+    def root
+      ROOT
+    end
+
+    def rackup
+      "#{ROOT}/bin/rackup"
+    end
+
+    def GET(path, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        get = Net::HTTP::Get.new(path, header)
+        get.basic_auth user, passwd if user && passwd
+        http.request(get) { |response|
+          @status = response.code.to_i
+          if response.content_type == "text/yaml"
+            load_yaml(response)
+          else
+            @response = response
+          end
+        }
+      }
+    end
+
+    def POST(path, formdata={}, header={})
+      Net::HTTP.start(@host, @port) { |http|
+        user = header.delete(:user)
+        passwd = header.delete(:passwd)
+
+        post = Net::HTTP::Post.new(path, header)
+        post.form_data = formdata
+        post.basic_auth user, passwd if user && passwd
+        http.request(post) { |response|
+          @status = response.code.to_i
+          @response = YAML.load(response.body)
+        }
+      }
+    end
+    
+    def load_yaml(response)
+      begin
+        @response = YAML.load(response.body)
+      rescue ArgumentError
+        @response = nil
+      end
+    end
+  end
+end