serverside 0.3.1 → 0.4.1

data/lib/serverside/http/parsing.rb

@@ -0,0 +1,175 @@
+module ServerSide::HTTP
+  module Parsing
+    REQUEST_LINE_RE = /([A-Za-z0-9]+)\s(\/[^\/\?]*(?:\/[^\/\?]+)*)\/?(?:\?(.*))?\sHTTP\/(.+)/.freeze
+
+    # Parses a request line into a method, URI, query and HTTP version parts.
+    # If a query is included, it is parsed into query parameters.
+    def parse_request_line(line)
+      if line =~ REQUEST_LINE_RE
+        @request_line = line
+        @method, @uri, @query, @http_version = $1.downcase.to_sym, $2, $3, $4
+        @params = @query ? parse_query_parameters(@query) : {}
+      else
+        raise MalformedRequestError, "Invalid request format"
+      end
+    end
+
+    HEADER_RE = /([^:]+):\s*(.*)/.freeze
+    
+    # Parses an HTTP header.
+    def parse_header(line)
+      if line =~ HEADER_RE
+        k = $1.freeze
+        v = $2.freeze
+        case k
+        when CONTENT_LENGTH: @content_length = v.to_i
+        when CONNECTION: @persistent = v == KEEP_ALIVE
+        when COOKIE: parse_cookies(v)
+        end
+        @request_headers[k] = v
+      else
+        raise MalformedRequestError, "Invalid header format"
+      end
+    end
+    
+    AMPERSAND = '&'.freeze
+    PARAMETER_RE = /^(.{1,64})=(.{0,8192})$/.freeze
+
+    # Parses query parameters by splitting the query string and unescaping
+    # parameter values.
+    def parse_query_parameters(query)
+      query.split(AMPERSAND).inject({}) do |m, i|
+        if i =~ PARAMETER_RE
+          m[$1.to_sym] = $2.uri_unescape
+        else
+          raise MalformedRequestError, "Invalid parameter format"
+        end
+        m
+      end
+    end
+    
+    COOKIE_RE = /^(.+)=(.*)$/.freeze
+    SEMICOLON = ';'.freeze
+    
+    # Parses a cookies header.
+    def parse_cookies(cookies)
+      cookies.split(SEMICOLON).each do |c|
+        if c.strip =~ COOKIE_RE
+          @request_cookies[$1.to_sym] = $2.uri_unescape
+        else
+          raise MalformedRequestError, "Invalid cookie format"
+        end
+      end
+    end
+    
+    BOUNDARY_FIX = '--'.freeze
+    
+    # Parses the request body.
+    def parse_request_body(body)
+      case @request_headers[CONTENT_TYPE]
+      when MULTIPART_FORM_DATA_RE:
+        parse_multi_part(body, BOUNDARY_FIX + $1) # body.dup so we keep the original request body?
+      when FORM_URL_ENCODED:
+        parse_form_url_encoded(body)
+      end
+    end
+    
+    # Parses a multipart request body.
+    def parse_multi_part(body, boundary)
+      while part = body.get_up_to_boundary_with_crlf(boundary)
+        unless part.empty?
+          parse_part(part)
+        end
+      end
+    end
+    
+    # Parses a part of a multipart body.
+    def parse_part(part)
+      part_name = nil
+      file_name = nil
+      file_type = nil
+      # part headers
+      while (line = part.get_line)
+        break if line.empty?
+        if line =~ HEADER_RE
+          k = $1.freeze
+          v = $2.freeze
+          case k
+          when CONTENT_DISPOSITION:
+            case v
+            when DISPOSITION_FORM_DATA_RE:
+              p [$1, $2, $3]
+              part_name = $1.to_sym
+              file_name = $3
+            end
+          when CONTENT_TYPE:
+            file_type = v
+          end
+        else
+          raise MalformedRequestError, "Invalid header in part"
+        end
+      end
+      # check if we got the content name
+      unless part_name
+        raise MalformedRequestError, "Invalid part content"
+      end
+      # part body
+      part_body = part.chomp! # what's left of it
+      @params ||= {}
+      @params[part_name] = file_name ? 
+        {:file_name => file_name, :file_content => part_body, :file_type => file_type} :
+        part_body
+    end
+    
+    # Parses query parameters passed in the body (for POST requests.)
+    def parse_form_url_encoded(body)
+      @params ||= {}
+      @params.merge!(parse_query_parameters(body))
+    end
+    
+    # Returns the host specified in the Host header.
+    def host
+      parse_host_header unless @host_header_parsed
+      @host
+    end
+    
+    # Returns the port number if specified in the Host header.
+    def port
+      parse_host_header unless @host_header_parsed
+      @port
+    end
+    
+    HOST_PORT_RE = /^([^:]+):(.+)$/.freeze
+
+    # Parses the Host header.
+    def parse_host_header
+      h = @request_headers[HOST]
+      if h =~ HOST_PORT_RE
+        @host = $1
+        @port = $2.to_i
+      else
+        @host = h
+      end
+      @host_header_parsed = true
+    end
+    
+    # Returns the client name. The client name is either the value of the
+    # X-Forwarded-For header, or the result of get_peername.
+    def client_name
+      unless @client_name
+        @client_name = @request_headers[X_FORWARDED_FOR]
+        unless @client_name
+          if addr = get_peername
+            p, @client_name = Socket.unpack_sockaddr_in(addr)
+          end
+        end
+      end
+      @client_name
+    end
+    
+    # Returns the request content type.
+    def content_type
+      @content_type ||= @request_headers[CONTENT_TYPE]
+    end
+  end
+end

data/lib/serverside/http/response.rb

@@ -0,0 +1,91 @@
+module ServerSide::HTTP
+  module Response
+    # Adds a header to the response.
+    def add_header(k, v)
+      @response_headers << "#{k}: #{v}\r\n"
+    end
+    
+    # Sends a representation with a content type and a body.
+    def send_representation(status, content_type, body)
+      add_header(CONTENT_TYPE, content_type)
+      send_response(status, body)
+    end
+    
+    # Sends a file representation. If the request method is HEAD, the response
+    # body is ommitted.
+    def send_file(status, content_type, fn)
+      add_header(CONTENT_TYPE, content_type)
+      if @method == :head
+        send_response(status, nil, File.size(fn))
+      else
+        send_response(status, IO.read(fn))
+      end
+    end
+    
+    def send_template(status, content_type, template, binding)
+      body = ServerSide::Template.render(template, binding)
+      send_representation(status, content_type, body)
+    end
+    
+    # Sends an error response. The HTTP status code is derived from the error
+    # class.
+    def send_error_response(e)
+      send_response(e.http_status, e.message)
+    end
+    
+    # Sends an HTTP response.
+    def send_response(status, body = nil, content_length = nil)
+      # if the connection is to be closed, we add the Connection: close header.
+      # prepare date and other headers
+      add_header(DATE, Time.now.httpdate)
+      if (content_length ||= body && body.size)
+        add_header(CONTENT_LENGTH, content_length)
+      else
+        @persistent = false
+      end
+      unless @persistent
+        @response_headers << CONNECTION_CLOSE
+      end
+      @response_sent = true
+      send_data "HTTP/1.1 #{status}\r\n#{@response_headers.join}\r\n#{body}"
+    end
+    
+    def redirect(location, permanent = false)
+      add_header(LOCATION, location)
+      send_response(permanent ? STATUS_MOVED_PERMANENTLY : STATUS_FOUND,'')
+    end
+    
+    # Starts a stream
+    def start_stream(status, content_type = nil, body = nil)
+      @streaming = true
+      if content_type
+        add_header(CONTENT_TYPE, content_type)
+      end
+      send_response(status)
+      if body
+        send_data(body)
+      end
+    end
+    
+    def stream(body)
+      send_data(body)
+    end
+    
+    ROOT_PATH = '/'.freeze
+    
+    # Adds a cookie to the response headers.
+    def set_cookie(name, value, expires, path = nil, domain = nil)
+      path ||= ROOT_PATH
+      v = "#{name}=#{value.to_s.uri_escape}; path=#{path}; expires=#{expires.rfc2822}"
+      if domain
+        v << "; domain=#{domain}"
+      end
+      add_header(SET_COOKIE, v)
+    end
+    
+    # Adds an expired cookie to the response headers.
+    def delete_cookie(name, path = nil, domain = nil)
+      set_cookie(name, nil, COOKIE_EXPIRED_TIME, path, domain)
+    end
+  end
+end

data/lib/serverside/http/server.rb

@@ -0,0 +1,194 @@
+require 'rubygems'
+require 'eventmachine'
+require 'time'
+
+# Use epoll if available
+EventMachine.epoll
+
+module ServerSide::HTTP
+  # The HTTP server is implemented as a simple state-machine with the following
+  # states:
+  # state_initial - initialize request variables.
+  # state_request_line - wait for and parse the request line.
+  # state_request_headers - wait for and parse header lines.
+  # state_request_body - wait for and parse the request body.
+  # state_response - send a response.
+  # state_done - the connection is closed.
+  #
+  # The server supports persistent connections (if the request is in HTTP 1.1).
+  # In that case, after responding to the request the state is changed back to
+  # request_line.
+  module Server
+    # Creates a new server module
+    def self.new
+      Module.new do
+        # include the HTTP state machine and everything else
+        include ServerSide::HTTP::Server
+        
+        # define a start method for starting the server
+        def self.start(addr, port)
+          EventMachine::run do
+            EventMachine::start_server addr, port, self
+          end
+        end
+        
+        # invoke the supplied block for application-specific behaviors.
+        yield
+      end
+    end
+    
+    # include the Parsing, Response and Caching modules.
+    include ServerSide::HTTP::Parsing
+    include ServerSide::HTTP::Response
+    include ServerSide::HTTP::Caching
+    
+    # attribute readers
+    attr_reader :request_line, :method, :uri, :query, :http_version, :params
+    attr_reader :content_length, :persistent, :request_headers
+    attr_reader :request_cookies, :request_body
+
+    # post_init creates a new @in buffer and sets the connection state to 
+    # initial.
+    def post_init
+      # initialize the in buffer
+      @in = ''
+      
+      # set state to initial
+      set_state(:state_initial)
+    end
+    
+    # receive_data is a callback invoked whenever new data is received on the
+    # connection. The incoming data is added to the @in buffer and the state
+    # method is invoked.
+    def receive_data(data)
+      @in << data
+      send(@state)
+    rescue => e
+      # if an error is raised, we send an error response
+      send_error_response(e) unless @state == :done
+    end
+    
+    # set_state is called whenever a state transition occurs. It invokes the
+    # state method.
+    def set_state(s)
+      @state = s
+      send(s)
+    rescue => e
+      # if an error is raised, we send an error response
+      send_error_response(e) unless @state == :done
+    end
+    
+    # state_initial initializes @request_headers, @request_header_count,
+    # @request_cookies and @response_headers. It immediately transitions to the 
+    # request_line state.
+    def state_initial
+      # initialize request and response variables
+      @request_line = nil
+      @response_sent = false
+      @request_headers = {}
+      @request_header_count = 0
+      @request_cookies = {}
+      @response_headers = []
+      @content_length = nil
+      
+      # immediately transition to the request_line state
+      set_state(:state_request_line)
+    end
+  
+    # state_request_line waits for the HTTP request line and parses it once it
+    # arrives. If the request line is too big, an error is raised. The request
+    # line supplies information including the 
+    def state_request_line
+      # check request line size
+      if @in.size > MAX_REQUEST_LINE_SIZE
+        raise MalformedRequestError, "Invalid request size"
+      end
+      if line = @in.get_line
+        parse_request_line(line)
+        # HTTP 1.1 connections are persistent by default.
+        @persistent = @http_version == VERSION_1_1
+        set_state(:state_request_headers)
+      end
+    end
+  
+    # state_request_headers parses each header as it arrives. If too many
+    # headers are included or a header exceeds the maximum header size,
+    # an error is raised.
+    def state_request_headers
+      while line = @in.get_line
+        # Check header size
+        if line.size > MAX_HEADER_SIZE
+          raise MalformedRequestError, "Invalid header size"
+        # If the line empty then we move to the next state
+        elsif line.empty?
+          expecting_body = @content_length && (@content_length > 0)
+          set_state(expecting_body ? :state_request_body : :state_response)
+        else
+          # check header count
+          if (@request_header_count += 1) > MAX_HEADER_COUNT
+            raise MalformedRequestError, "Too many headers"
+          else
+            parse_header(line)
+          end
+        end
+      end
+    end
+      
+    # state_request_body waits for the request body to arrive and then parses
+    # the body. Once the body is parsed, the connection transitions to the 
+    # response state.
+    def state_request_body
+      if @in.size >= @content_length
+        @request_body = @in.slice!(0...@content_length)
+        parse_request_body(@request_body)
+        set_state(:state_response)
+      end
+    end
+    
+    # state_response invokes the handle method. If no response was sent, an
+    # error is raised. After the response is sent, the connection is either
+    # closed or goes back to the initial state.
+    def state_response
+      handle
+      unless @response_sent || @streaming
+        raise "No handler found for this URI (#{@uri})"
+      end
+    ensure
+      unless @streaming
+        set_state(@persistent ? :state_initial : :state_done)
+      end
+    end
+    
+    # state_done closes the connection.
+    def state_done
+      close_connection_after_writing
+    end
+    
+    # periodically implements a periodical timer. The timer is invoked until
+    # the supplied block returns false or nil.
+    def periodically(period, &block)
+      EventMachine::add_timer(period) do
+        if block.call
+          periodically(period, &block)
+        end
+      end
+    end
+
+    # periodically implements a periodical timer. The timer is invoked until
+    # the supplied block returns false or nil.
+    def streaming_periodically(period, &block)
+      @streaming = true
+      if block.call # invoke block for the first time
+        EventMachine::add_timer(period) do
+          if block.call
+            streaming_periodically(period, &block)
+          else
+            set_state(@persistent ? :state_initial : :state_done)
+          end
+        end
+      else
+        set_state(@persistent ? :state_initial : :state_done)
+      end
+    end
+  end
+end

data/lib/serverside/http/static.rb

@@ -0,0 +1,72 @@
+module ServerSide::HTTP
+  module Static
+    MIME_TYPES = {
+      :html => 'text/html'.freeze,
+      :css => 'text/css'.freeze,
+      :js => 'text/javascript'.freeze,
+
+      :gif => 'image/gif'.freeze,
+      :jpg => 'image/jpeg'.freeze,
+      :jpeg => 'image/jpeg'.freeze,
+      :png => 'image/png'.freeze,
+      :ico => 'image/x-icon'.freeze
+    }
+    MIME_TYPES.default = 'text/plain'.freeze
+    
+    CACHE_AGES = {}
+    CACHE_AGES.default = 86400 # one day
+    
+    INVALID_PATH_RE = /\.\./.freeze
+    
+    # Serves a static file or directory.
+    def serve_static(fn)
+      if fn =~ INVALID_PATH_RE
+        raise MalformedRequestError, "Invalid path specified (#{@uri})"
+      elsif !File.exists?(fn)
+        raise FileNotFoundError, "File not found (#{@uri})"
+      end
+      
+      if File.directory?(fn)
+        send_directory_representation(fn)
+      else
+        send_file_representation(fn)
+      end
+    end
+    
+    # Sends a file representation, setting caching-related headers.
+    def send_file_representation(fn)
+      ext = File.extension(fn)
+      expires = Time.now + CACHE_AGES[ext]
+      cache :etag => File.etag(fn), :expires => expires, :last_modified => File.mtime(fn) do
+        send_file(STATUS_OK, MIME_TYPES[ext], fn)
+      end
+    end
+    
+    DIR_TEMPLATE = '<html><head><title>Directory Listing for %s</title></head><body><h2>Directory listing for %s:</h2><ul>%s</ul></body></html>'.freeze
+    DIR_LISTING = '<li><a href="%s">%s</a><br/></li>'.freeze
+
+    # Sends a directory representation.
+    def send_directory_representation(dir)
+      entries = Dir.entries(dir)
+      entries.reject! {|fn| fn =~ /^\./}
+      entries.unshift('..') if dir != './'
+      
+      list = entries.map {|e| DIR_LISTING % [@uri/e, e]}.join
+      html = DIR_TEMPLATE % [dir, dir, list]
+      send_representation(STATUS_OK, MIME_TYPES[:html], html)
+    end
+  end
+end
+
+class File
+  # Returns an Apache-style ETag for the specified file.
+  def self.etag(fn)
+    stat = File.stat(fn)
+    "#{stat.mtime.to_i.to_s(16)}-#{stat.size.to_s(16)}-#{stat.ino.to_s(16)}"
+  end
+  
+  # Returns the extension for the file name as a symbol.
+  def self.extension(fn)
+    (ext = (fn =~ /\.([^\.\/]+)$/) && $1) ? ext.to_sym : nil
+  end
+end

data/lib/serverside/http.rb

@@ -0,0 +1,14 @@
+module ServerSide
+  module HTTP
+  end
+end
+
+http_dir = File.dirname(__FILE__)/'http'
+
+require http_dir/'const'
+require http_dir/'error'
+require http_dir/'parsing'
+require http_dir/'response'
+require http_dir/'caching'
+require http_dir/'static'
+require http_dir/'server'