serverside 0.1.59

data/lib/serverside/connection.rb

@@ -0,0 +1,115 @@
+module ServerSide
+  # The Connection module takes care of HTTP connection. While most HTTP servers
+  # (at least the OO ones) will define separate classes for request and 
+  # response, I chose to use the concept of a connection both for better
+  # performance, and also because a single connection might handle multiple
+  # requests, if using HTTP 1.1 persistent connection.
+  module Connection
+    # A bunch of frozen constants to make the parsing of requests and rendering
+    # of responses faster than otherwise.
+    module Const
+      LineBreak = "\r\n".freeze
+      # Here's a nice one - parses the first line of a request.
+      RequestRegexp = /([A-Za-z0-9]+)\s(\/[^\/\?]*(\/[^\/\?]+)*)\/?(\?(.*))?\sHTTP\/(.+)\r/.freeze
+      # Regexp for parsing headers.
+      HeaderRegexp = /([^:]+):\s?(.*)\r\n/.freeze
+      ContentLength = 'Content-Length'.freeze
+      Version_1_1 = '1.1'.freeze
+      Connection = 'Connection'.freeze
+      Close = 'close'.freeze
+      Ampersand = '&'.freeze
+      # Regexp for parsing URI parameters.
+      ParameterRegexp = /(.+)=(.*)/.freeze
+      EqualSign = '='.freeze
+      StatusClose = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%sContent-Length: %d\r\n\r\n".freeze
+      StatusStream = "HTTP/1.1 %d\r\nConnection: close\r\nContent-Type: %s\r\n%s\r\n".freeze
+      StatusPersist = "HTTP/1.1 %d\r\nContent-Type: %s\r\n%sContent-Length: %d\r\n\r\n".freeze
+      Header = "%s: %s\r\n".freeze
+      Empty = ''.freeze
+      Slash = '/'.freeze
+    end
+
+    # This is the base request class. When a new request is created, it starts
+    # a thread in which it is parsed and processed.
+    #
+    # Connection::Base is overriden by applications to create 
+    # application-specific behavior.
+    class Base
+      # Initializes the request instance. A new thread is created for
+      # processing requests.
+      def initialize(conn)
+        @conn = conn
+        @thread = Thread.new {process}
+      end
+      
+      # Processes incoming requests by parsing them and then responding. If
+      # any error occurs, or the connection is not persistent, the connection is
+      # closed.
+      def process
+        while true
+          break unless parse_request
+          respond
+          break unless @persistent
+        end
+      rescue
+        # We don't care. Just close the connection.
+      ensure
+        @conn.close
+      end
+    
+      # Parses an HTTP request. If the request is not valid, nil is returned.
+      # Otherwise, the HTTP headers are returned. Also determines whether the
+      # connection is persistent (by checking the HTTP version and the 
+      # 'Connection' header).
+      def parse_request
+        return nil unless @conn.gets =~ Const::RequestRegexp
+        @method, @path, @query, @version = $1.downcase.to_sym, $2, $5, $6
+        @parameters = @query ? parse_parameters(@query) : {}
+        @headers = {}
+        while (line = @conn.gets)
+          break if line.nil? || (line == Const::LineBreak)
+          if line =~ Const::HeaderRegexp
+            @headers[$1.freeze] = $2.freeze
+          end
+        end
+        @persistent = (@version == Const::Version_1_1) && 
+          (@headers[Const::Connection] != Const::Close)
+        @headers
+      end
+      
+      # Parses query parameters by splitting the query string and unescaping
+      # parameter values.
+      def parse_parameters(query)
+        query.split(Const::Ampersand).inject({}) do |m, i|
+          if i =~ Const::ParameterRegexp
+            m[$1.to_sym] = $2.uri_unescape
+          end
+          m
+        end
+      end
+    
+      # Sends an HTTP response.
+      def send_response(status, content_type, body = nil, content_length = nil, 
+        headers = nil)
+        h = headers ? 
+          headers.inject('') {|m, kv| m << (Const::Header % kv)} : Const::Empty
+
+        content_length = body.length if content_length.nil? && body
+        @persistent = false if content_length.nil?
+        
+        # Select the right format to use according to circumstances.
+        @conn << ((@persistent ? Const::StatusPersist : 
+          (body ? Const::StatusClose : Const::StatusStream)) % 
+          [status, content_type, h, content_length])
+        @conn << body if body
+      rescue
+        @persistent = false
+      end
+      
+      # Streams additional data to the client.
+      def stream(body)
+        (@conn << body if body) rescue (@persistent = false)
+      end
+    end
+  end
+end

data/lib/serverside/core_ext.rb

@@ -0,0 +1,27 @@
+# String extension methods.
+class String
+  # Encodes a normal string to a URI string.
+  def uri_escape
+    gsub(/([^ a-zA-Z0-9_.-]+)/n) {'%'+$1.unpack('H2'*$1.size).
+      join('%').upcase}.tr(' ', '+')
+  end
+  
+  # Decodes a URI string to a normal string.
+  def uri_unescape
+    tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){[$1.delete('%')].pack('H*')}
+  end
+  
+  # Concatenates a path (do we really need this sugar?)
+  def /(o)
+    File.join(self, o.to_s)
+  end
+end
+
+# Symbol extensions and overrides.
+class Symbol
+  # A faster to_s method. This is called a lot, and memoization gives us
+  # performance between 10%-35% better.
+  def to_s
+    @_to_s || (@_to_s = id2name)
+  end
+end

data/lib/serverside/daemon.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+
+# The Daemon module takes care of starting and stopping daemons.
+module Daemon
+  WorkingDirectory = FileUtils.pwd
+
+  class Base
+    def self.pid_fn
+      File.join(WorkingDirectory, "#{name.gsub('::', '.').downcase}.pid")
+    end
+  end
+  
+  # Stores and recalls the daemon pid.
+  module PidFile
+    # Stores the daemon pid.
+    def self.store(daemon, pid)
+      File.open(daemon.pid_fn, 'w') {|f| f << pid}
+    end
+    
+    # Recalls the daemon pid. If the pid can not be recalled, an error is 
+    # raised.
+    def self.recall(daemon)
+      IO.read(daemon.pid_fn).to_i
+    rescue
+      raise 'Pid not found. Is the daemon started?'
+    end
+  end
+  
+  # Controls a daemon according to the supplied command or command-line 
+  # parameter. If an invalid command is specified, an error is raised.
+  def self.control(daemon, cmd = nil)
+    case (cmd || (!ARGV.empty? && ARGV[0]) || :nil).to_sym
+    when :start
+      start(daemon)
+    when :stop
+      stop(daemon)
+    when :restart
+      stop(daemon)
+      start(daemon)
+    else
+      raise 'Invalid command. Please specify start, stop or restart.'
+    end
+  end
+  
+  # Starts the daemon by forking and bcoming session leader.
+  def self.start(daemon)
+    fork do
+      Process.setsid
+      exit if fork
+      PidFile.store(daemon, Process.pid)
+      Dir.chdir WorkingDirectory
+      File.umask 0000
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen "/dev/null", "a"
+      STDERR.reopen STDOUT
+      trap("TERM") {daemon.stop; exit}
+      daemon.start
+    end
+  end
+
+  # Stops the daemon by sending it a TERM signal.
+  def self.stop(daemon)
+    pid = PidFile.recall(daemon)
+    FileUtils.rm(daemon.pid_fn)
+    pid && Process.kill("TERM", pid)
+  end
+end

data/lib/serverside/server.rb

@@ -0,0 +1,18 @@
+require 'socket'
+
+module ServerSide
+  # The ServerSide HTTP server is designed to be fast and simple. It is also
+  # designed to support both HTTP 1.1 persistent connections, and HTTP streaming
+  # for applications which use Comet techniques.
+  class Server
+    # Creates a new server by opening a listening socket and starting an accept
+    # loop. When a new connection is accepted, a new instance of the the 
+    # supplied connection class is instantiated and passed the connection for
+    # processing.
+    def initialize(host, port, connection_class)
+      @connection_class = connection_class
+      @server = TCPServer.new(host, port)
+      loop {@connection_class.new(@server.accept)}
+    end
+  end
+end

data/lib/serverside/static.rb

@@ -0,0 +1,96 @@
+module ServerSide
+  # This module provides functionality for serving files and directory listings
+  # over HTTP. It is mainly used by ServerSide::Connection::Static.
+  module StaticFiles
+    # Frozen constants to be used by the module.
+    module Const
+      ETag = 'ETag'.freeze
+      ETagFormat = '%x:%x:%x'.inspect.freeze
+      CacheControl = 'Cache-Control'.freeze
+      MaxAge = "max-age=#{86400 * 30}".freeze
+      IfNoneMatch = 'If-None-Match'.freeze
+      NotModifiedClose = "HTTP/1.1 304 Not Modified\r\nConnection: close\r\nContent-Length: 0\r\nETag: %s\r\nCache-Control: #{MaxAge}\r\n\r\n".freeze
+      NotModifiedPersist = "HTTP/1.1 304 Not Modified\r\nContent-Length: 0\r\nETag: %s\r\nCache-Control: #{MaxAge}\r\n\r\n".freeze
+      TextPlain = 'text/plain'.freeze
+      MaxCacheFileSize = 100000.freeze # 100KB for the moment
+      
+      DirListingStart = '<html><head><title>Directory Listing for %s</title></head><body><h2>Directory listing for %s:</h2>'.freeze
+      DirListing = '<a href="%s">%s</a><br/>'.freeze
+      DirListingStop = '</body></html>'.freeze
+    end
+    
+    @@mime_types = Hash.new {|h, k| ServerSide::StaticFiles::Const::TextPlain}
+    @@mime_types.merge!({
+      '.html'.freeze => 'text/html'.freeze,
+      '.css'.freeze => 'text/css'.freeze,
+      '.js'.freeze => 'text/javascript'.freeze,
+
+      '.gif'.freeze => 'image/gif'.freeze,
+      '.jpg'.freeze => 'image/jpeg'.freeze,
+      '.jpeg'.freeze => 'image/jpeg'.freeze,
+      '.png'.freeze => 'image/png'.freeze
+    })
+    
+    @@static_files = {}
+    
+    # Serves a file over HTTP. The file is cached in memory for later retrieval.
+    # If the If-None-Match header is included with an ETag, it is checked
+    # against the file's current ETag. If there's a match, a 304 response is
+    # rendered.
+    def serve_file(fn)
+      stat = File.stat(fn)
+      etag = (Const::ETagFormat % [stat.mtime.to_i, stat.size, stat.ino]).freeze
+      unless etag == @headers[Const::IfNoneMatch]
+        if @@static_files[fn] && (@@static_files[fn][0] == etag)
+          content = @@static_files[fn][1]
+        else
+          content = IO.read(fn).freeze
+          @@static_files[fn] = [etag.freeze, content]
+        end
+        
+        send_response(200, @@mime_types[File.extname(fn)], content, stat.size, 
+          {Const::ETag => etag, Const::CacheControl => Const::MaxAge})
+      else
+        @conn << ((@persistent ? Const::NotModifiedPersist : 
+          Const::NotModifiedClose) % etag)
+      end
+    rescue => e
+      send_response(404, Const::TextPlain, 'Error reading file.')
+    end
+    
+    # Serves a directory listing over HTTP in the form of an HTML page.
+    def serve_dir(dir)
+      html = (Const::DirListingStart % [@path, @path]) +
+        Dir.entries(dir).inject('') {|m, fn|
+          (fn == '.') ? m : m << Const::DirListing % [@path/fn, fn]
+        } + Const::DirListingStop
+      send_response(200, 'text/html', html)
+    end
+  end
+  
+  module Connection
+    module Const
+      WD = '.'.freeze
+      FileNotFound = "Couldn't open file %s.".freeze
+    end
+    
+    # A connection type for serving static files.
+    class Static < Base
+      include StaticFiles
+      
+      # Responds with a file's content or a directory listing. If the path
+      # does not exist, a 404 response is rendered.
+      def respond
+        fn = './%s' % @path
+        if File.file?(fn)
+          serve_file(fn)
+        elsif File.directory?(fn)
+          serve_dir(fn)
+        else
+          send_response(404, 'text', Const::FileNotFound % @path)
+        end
+      end
+    end
+  end
+end
+

data/test/functional/primitive_static_server_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'net/http'
+
+class StaticServerTest < Test::Unit::TestCase
+  
+  class StaticConnection < ServerSide::Connection::Base
+    def respond
+      status = 200
+      body = IO.read('.'/@path)
+    rescue => e
+      status = 404
+      body = "Couldn't open file #{@path}."
+    ensure
+      send_response(status, 'text', body)
+    end
+  end
+  
+  def test_basic
+    t = Thread.new {ServerSide::Server.new('0.0.0.0', 17654, StaticConnection)}
+    sleep 0.1
+
+    h = Net::HTTP.new('localhost', 17654)
+    resp, data = h.get('/qqq', nil)
+    assert_equal 404, resp.code.to_i
+    assert_equal "Couldn't open file /qqq.", data
+    
+    h = Net::HTTP.new('localhost', 17654)
+    resp, data = h.get("/#{__FILE__}", nil)
+    assert_equal 200, resp.code.to_i
+    assert_equal IO.read(__FILE__), data
+    assert_equal 'text', resp['Content-Type']
+    # Net::HTTP includes this header in the request, so our server returns
+    # likewise.
+    assert_equal 'close', resp['Connection']
+    t.exit
+  end
+end

data/test/functional/static_profile.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'serverside'
+require 'fileutils'
+
+FileUtils.cd(File.dirname(__FILE__))
+
+pid = fork do
+  trap('TERM') {exit}
+  require 'profile'
+  ServerSide::Server.new('0.0.0.0', 8000, ServerSide::Connection::Static)
+end
+
+puts "Please wait..."
+`ab -n 1000 http://localhost:8000/#{File.basename(__FILE__)}`
+puts
+Process.kill('TERM', pid)
+puts

data/test/functional/static_rfuzz.rb

@@ -0,0 +1,67 @@
+# Simple script that hits a host port and URI with a bunch of connections
+# and measures the timings.
+
+require 'rubygems'
+require 'rfuzz/client'
+require 'rfuzz/stats'
+include RFuzz
+
+class StatsTracker
+
+  def initialize
+    @stats = {}
+    @begins = {}
+    @error_count = 0
+  end
+
+  def mark(event)
+    @begins[event] = Time.now
+  end
+
+  def sample(event)
+    @stats[event] ||= Stats.new(event.to_s)
+    @stats[event].sample(Time.now - @begins[event])
+  end
+
+  def method_missing(event, *args)
+    case args[0]
+    when :begins
+      mark(:request) if event == :connect
+      mark(event)
+    when :ends
+      sample(:request) if event == :close
+      sample(event)
+    when :error
+      @error_count += 1
+    end
+  end
+
+  def to_s
+    request = @stats[:request]
+    @stats.delete :request
+    "#{request}\n----\n#{@stats.values.join("\n")}\nErrors: #@error_count"
+  end
+end
+
+
+if ARGV.length != 4
+  STDERR.puts "usage:  ruby perftest.rb host port uri count"
+  exit 1
+end
+
+host, port, uri, count = ARGV[0], ARGV[1], ARGV[2], ARGV[3].to_i
+
+codes = {}
+cl = HttpClient.new(host, port, :notifier => StatsTracker.new)
+count.times do
+  begin
+    resp = cl.get(uri)
+    code = resp.http_status.to_i
+    codes[code] ||= 0
+    codes[code] += 1
+  rescue Object
+  end
+end
+
+puts cl.notifier.to_s
+puts "Status Codes: #{codes.inspect}"