serverside 0.3.1 → 0.4.1

data/README

@@ -1,9 +1,9 @@
-= about ServerSide
+== ServerSide: A Fast HTTP Server for Ruby
 
-ServerSide is an HTTP server framework designed to be as fast as possible, and
-as easy as possible to use. ServerSide includes a full-featured HTTP server, a
-controller-view system and a bunch of other tools to easily create servers and
-clusters of servers.
+ServerSide is an HTTP server based on EventMachine, a fast event processing
+library that offers superior scalability. ServerSide offers features such as
+persistent connections, HTTP streaming, HTTP caching, and more. ServerSide
+also includes tools to easily serve static files and create clusters.
 
 == Resources
 
@@ -16,6 +16,10 @@ To check out the source code:
   
   svn co http://serverside.googlecode.com/svn/trunk
 
+=== Contact
+
+If you have any comments or suggestions please send an email to ciconia at gmail.com and I'll get back to you.
+
 == Installation
 
   sudo gem install serverside
@@ -34,7 +38,7 @@ To run the server without forking, use the 'serve' command:
 
   serverside serve .
 
-== Serving ERb Templates
+=== Serving ERb Templates
 
 ServerSide can render ERb[http://www.ruby-doc.org/stdlib/libdoc/erb/rdoc/] 
 templates in a fashion similar to PHP. You can store templates in .rhtml files, 
@@ -42,15 +46,15 @@ and ServerSide takes care of all the rest. ServerSide is also smart enough to
 allow you to use nice looking URL's with your templates, and automatically adds 
 the .rhtml extension if the file is there.
  
-== Serving Dynamic Content
+=== Serving Dynamic Content
 
 By default ServerSide serves static files, but you can change the behavior by
 creating custom {routing rules}[classes/ServerSide/Connection/Router.html].
 Here's a simple routing rule:
 
-  ServerSide::Router.route(:path => '/hello/:name') {
-    send_response(200, 'text', "Hello #{@parameters[:name]}!")
-  }
+route :path => '/hello/:name' do
+  send_response(200, 'text', "Hello #{@params[:name]}")
+end
 
 The ServerSide framework also lets you route requests based on any attribute of
 incoming requests, such as host name, path, URL parameters etc.
@@ -60,7 +64,7 @@ or tell serverside to explicitly load a specific file:
 
   serverside start ~/myapp/myapp.rb
 
-== Running a Cluster of Servers
+=== Running a Cluster of Servers
 
 ServerSide makes it easy to control a cluster of servers. Just supply a range of
 ports instead of a single port:

data/Rakefile

@@ -6,9 +6,9 @@ require 'fileutils'
 include FileUtils
 
 NAME = "serverside"
-VERS = "0.3.1"
+VERS = "0.4.1"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
-RDOC_OPTS = ['--quiet', '--title', "ServerSide Documentation",
+RDOC_OPTS = ['--quiet', '--title', "ServerSide: a Fast Ruby Web Framework",
   "--opname", "index.html",
   "--line-numbers", 
   "--main", "README",
@@ -24,8 +24,8 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'doc/rdoc'
   rdoc.options += RDOC_OPTS
   rdoc.main = "README"
-  rdoc.title = "ServerSide Documentation"
-  rdoc.rdoc_files.add ['README', 'CHANGELOG', 'COPYING', 'lib/serverside.rb', 'lib/serverside/*.rb']
+  rdoc.title = "ServerSide: a Fast Ruby HTTP Server"
+  rdoc.rdoc_files.add ['README', 'COPYING', 'lib/serverside.rb', 'lib/serverside/**/*.rb']
 end
 
 spec = Gem::Specification.new do |s|
@@ -33,20 +33,22 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.extra_rdoc_files = ["README", "COPYING"]
   s.rdoc_options += RDOC_OPTS + 
     ['--exclude', '^(examples|extras)\/', '--exclude', 'lib/serverside.rb']
-  s.summary = "Performance-oriented web framework."
+  s.summary = "Fast Ruby HTTP Server."
   s.description = s.summary
   s.author = "Sharon Rosner"
   s.email = 'ciconia@gmail.com'
   s.homepage = 'http://code.google.com/p/serverside/'
   s.executables = ['serverside']
 
+  s.add_dependency('eventmachine')
+  s.add_dependency('erubis')
   s.add_dependency('metaid')
-  s.required_ruby_version = '>= 1.8.2'
+  s.required_ruby_version = '>= 1.8.5'
 
-  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*") 
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
       
   s.require_path = "lib"
   s.bindir = "bin"
@@ -74,26 +76,24 @@ end
 
 require 'spec/rake/spectask'
 
-desc "Run specs with coverage"
+desc "Run specs"
 Spec::Rake::SpecTask.new('spec') do |t|
   t.spec_files = FileList['spec/*_spec.rb']
-  t.rcov = true
 end
 
-#require 'spec/rake/rcov_verify'
-
-#RCov::VerifyTask.new(:rcov_verify => :rcov) do |t|
-#  t.threshold = 95.4 # Make sure you have rcov 0.7 or higher!
-#  t.index_html = 'coverage/index.html'
-#end
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new('spec_coverage') do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.rcov = true
+end
 
 ##############################################################################
 # Statistics
 ##############################################################################
 
 STATS_DIRECTORIES = [
-  %w(Code                 lib/),
-  %w(Specification\ tests spec)
+  %w(Code   lib/),
+  %w(Spec   spec/)
 ].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
 
 desc "Report code statistics (KLOCs, etc) from the application"

data/bin/serverside

@@ -10,10 +10,10 @@ $cmd_config = {
 }
 
 opts = OptionParser.new do |opts|
-  opts.banner = "Usage: serverside start|stop|restart|serve [app1]"
+  opts.banner = "Usage: serverside start|stop|restart|serve [app_file]"
   opts.define_head "ServerSide, a fast and simple web framework for ruby."
   opts.separator ""
-  opts.separator "The supplied app path can be directory or file references. \
+  opts.separator "The supplied application path can be directory or file references. \
 If the path refers to a directory the system will try to load serverside.rb in \
 that directory. If no path is given, the current working directory is assumed."
   opts.separator ""
@@ -57,15 +57,22 @@ unless %w(start stop restart serve).include?($cmd)
   exit
 end
 
-path = ARGV.shift || '.'
-if File.file?(path)
-  require path
-else
-  fn = File.join(path, 'serverside.rb')
-  require fn if File.file?(fn)
+$path = ARGV.shift || '.'
+if File.file?($path)
+  app_code = IO.read($path)
+elsif File.file?($path/'serverside.rb')
+  app_code = IO.read($path/'serverside.rb')
 end
-unless ServerSide::Router.routes_defined?
-  ServerSide::Router.default_route {serve_static('.'/@path)}
+
+$server = ServerSide::HTTP::Server.new do
+  if app_code
+    module_eval(app_code)
+  else
+    include ServerSide::HTTP::Static
+    def handle
+      serve_static($path/@uri)
+    end
+  end
 end
 
 if $cmd == 'serve'
@@ -75,18 +82,15 @@ if $cmd == 'serve'
   end
   puts "Serving at #{$cmd_config[:host]}:#{$cmd_config[:ports].begin}..."
   trap('INT') {exit}
-  ServerSide::HTTP::Server.new($cmd_config[:host], $cmd_config[:ports].begin,
-    ServerSide::Router).start
+  
+  $server.start($cmd_config[:host], $cmd_config[:ports].begin)
 else
   daemon_class = Class.new(Daemon::Cluster) do
     meta_def(:pid_fn) {Daemon::WorkingDirectory/'serverside.pid'}
     meta_def(:server_loop) do |port|
-      ServerSide::HTTP::Server.new(
-        $cmd_config[:host], port, ServerSide::Router).start
+      $server.start($cmd_config[:host], port)
     end
     meta_def(:ports) {$cmd_config[:ports]}
   end
   Daemon.control(daemon_class, $cmd)
-
-#  ServerSide::Application.daemonize($cmd_config, $cmd)
 end

data/lib/serverside/cluster.rb

@@ -4,32 +4,6 @@ module Daemon
   # Implements a cluster controlling daemon. The daemon itself itself forks
   # a child process for each port.
   class Cluster < Base
-    # Stores and recalls pids for the child processes.
-    class PidFile
-      FN = 'serverside_cluster.pid'
-    
-      # Deletes the cluster's pid file.
-      def self.delete
-        FileUtils.rm(FN) if File.file?(FN)
-      end
-    
-      # Stores a pid in the cluster's pid file.
-      def self.store_pid(pid)
-        File.open(FN, 'a') {|f| f.puts pid}
-      end
-    
-      # Recalls all child pids.
-      def self.recall_pids
-        pids = []
-        File.open(FN, 'r') do |f|
-          while !f.eof?
-            pids << f.gets.to_i
-          end
-        end
-        pids
-      end
-    end
-
     # Forks a child process with a specific port.
     def self.fork_server(port)
       fork do
@@ -37,20 +11,17 @@ module Daemon
         server_loop(port)
       end
     end
+    
+    @@pids = []
   
     # Starts child processes.
     def self.start_servers
-      PidFile.delete
-      ports.each do |p|
-        PidFile.store_pid(fork_server(p))
-      end
+      ports.each {|p| @@pids << fork_server(p)}
     end
   
     # Stops child processes.
     def self.stop_servers
-      pids = PidFile.recall_pids
-      pids.each {|pid| begin; Process.kill('TERM', pid); rescue; end}
-      PidFile.delete
+      @@pids.each {|pid| Process.kill('TERM', pid) rescue nil}
     end
   
     # The main daemon loop. Does nothing for now.

data/lib/serverside/core_ext.rb

@@ -1,4 +1,6 @@
-# String extension methods.
+require 'md5'
+
+# String extensions.
 class String
   # Encodes a normal string to a URI string.
   def uri_escape
@@ -11,7 +13,11 @@ class String
     tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){[$1.delete('%')].pack('H*')}
   end
   
-  # Concatenates a path (do we really need this sugar?)
+  def html_escape
+    gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+  end
+  
+  # Concatenates a path (purely sugar)
   def /(o)
     File.join(self, o.to_s)
   end
@@ -21,14 +27,45 @@ class String
     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').
       tr("-", "_").downcase
   end
+  
+  # Converts an underscored name into a camelized name
+  def camelize
+    gsub(/(^|_)(.)/) {$2.upcase}
+  end
+  
+  LINE_RE = /^([^\r]*)\r\n/n.freeze
+  EMPTY_STRING = ''.freeze
+  
+  def get_line
+    sub!(LINE_RE, EMPTY_STRING) ? $1 : nil
+  end
+  
+  def get_up_to_boundary(boundary)
+    if i = index(boundary)
+      part = i > 0 ? self[0..(i - 1)] : ''
+      slice!(0..(i + boundary.size - 1))
+      part
+    end
+  end
+
+  def get_up_to_boundary_with_crlf(boundary)
+    if i = index(boundary)
+      part = i > 0 ? self[0..(i - 1)] : ''
+      slice!(0..(i + boundary.size + 1))
+      part
+    end
+  end
+  
+  def etag
+    MD5.hexdigest(self)
+  end
 end
 
-# Symbol extensions and overrides.
+# Symbol extensions.
 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)
+  # Concatenates a path (purely sugar)
+  def /(o)
+    File.join(self, o.to_s)
   end
 end
 
@@ -46,3 +83,15 @@ class Object
   end
 end
 
+# Coercion of boolean values to integer
+def true.to_i; -1; end
+def false.to_i; 0; end
+
+# Process extensions.
+module Process
+  # Checks for the existance of a process.
+  def self.exists?(pid)
+    getpgid(pid) && true rescue false
+  end
+end
+  

data/lib/serverside/daemon.rb

@@ -1,15 +1,5 @@
 require 'fileutils'
 
-class Object
-  def backtrace
-    raise RuntimeError
-  rescue => e
-    bt = e.backtrace.dup
-    bt.shift
-    bt
-  end
-end
-
 # The Daemon module takes care of starting and stopping daemons.
 module Daemon
   WorkingDirectory = FileUtils.pwd
@@ -49,7 +39,11 @@ module Daemon
     when :stop
       stop(daemon)
     when :restart
-      stop(daemon)
+      begin
+        stop(daemon)
+        sleep 2
+      rescue
+      end
       start(daemon)
     else
       raise 'Invalid command. Please specify start, stop or restart.'
@@ -64,9 +58,9 @@ module Daemon
       PidFile.store(daemon, Process.pid)
       Dir.chdir WorkingDirectory
       File.umask 0000
-#      STDIN.reopen "/dev/null"
-#      STDOUT.reopen "/dev/null", "a"
-#      STDERR.reopen STDOUT
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen "/dev/null", "a"
+      STDERR.reopen STDOUT
       trap("TERM") {daemon.stop; exit}
       daemon.start
     end
@@ -75,13 +69,12 @@ module Daemon
   # Stops the daemon by sending it a TERM signal.
   def self.stop(daemon)
     pid = PidFile.recall(daemon)
-    pid && Process.kill("TERM", pid)
+    pid && Process.kill("TERM", pid) rescue nil
     PidFile.remove(daemon)
   end
 
   def self.alive?(daemon)
     pid = PidFile.recall(daemon) rescue nil
-    return nil if !pid
-    `ps #{pid}` =~ /#{pid}/ ? true : nil
+    pid ? Process.exists?(pid) : false
   end
 end

data/lib/serverside/http/caching.rb

@@ -0,0 +1,79 @@
+module ServerSide::HTTP
+  # HTTP Caching behavior
+  module Caching
+    # Sets caching-related headers and validates If-Modified-Since and
+    # If-None-Match headers. If a match is found, a 304 response is sent.
+    # Otherwise, the supplied block is invoked.
+    def cache(opts)
+      not_modified = false
+      
+      # check etag
+      if etag = opts[:etag]
+        etag = "\"#{etag}\""
+        add_header(ETAG, etag) if etag
+        not_modified = etag_match(etag)
+      end
+      
+      # check last_modified
+      if last_modified = opts[:last_modified]
+        add_header(LAST_MODIFIED, last_modified)
+        not_modified ||= modified_match(last_modified)
+      end
+      
+      # check cache-control
+      remove_cache_control
+      if cache_control = opts[:cache_control]
+        add_header(CACHE_CONTROL, cache_control)
+      end
+      
+      # add an expires header
+      if expires = opts[:expires]
+        add_header(EXPIRES, expires.httpdate)
+      elsif age = opts[:age]
+        add_header(EXPIRES, (Time.now + age).httpdate)
+      end
+      
+      # if not modified, send a 304 response. Otherwise we yield to the
+      # supplied block.
+      not_modified ? 
+        send_response(STATUS_NOT_MODIFIED, nil) : yield
+    end
+    
+    COMMA = ','.freeze
+    
+    # Matches the supplied etag against any of the entities in the
+    # If-None-Match header.
+    def etag_match(etag)
+      matches = @request_headers[IF_NONE_MATCH]
+      if matches
+        matches.split(COMMA).each do |e|
+          
+          return true if e.strip == etag
+        end
+      end
+      false
+    end
+    
+    # Matches the supplied last modified date against the If-Modified-Since
+    # header.
+    def modified_match(last_modified)
+      if modified_since = @request_headers[IF_MODIFIED_SINCE]
+        last_modified.to_i == Time.parse(modified_since).to_i
+      else
+        false
+      end
+    rescue => e
+      raise MalformedRequestError, "Invalid value in If-Modified-Since header"
+    end
+    
+    # Sets the Cache-Control header.
+    def set_cache_control(directive)
+      add_header(CACHE_CONTROL, directive)
+    end
+    
+    def remove_cache_control
+      @response_headers.reject! {|h| h =~ /^#{CACHE_CONTROL}/}
+    end
+  end
+end
+

data/lib/serverside/http/const.rb

@@ -0,0 +1,69 @@
+module ServerSide::HTTP
+  # HTTP versions
+  VERSION_1_0 = '1.0'.freeze
+  VERSION_1_1 = '1.1'.freeze
+  
+  # maximum sizes
+  MAX_REQUEST_LINE_SIZE = 8192
+  MAX_HEADER_SIZE = 8192
+  MAX_HEADER_COUNT = 256 # should be enough methinks
+  
+  # request body and response body
+  CONTENT_LENGTH = 'Content-Length'.freeze
+  CONTENT_TYPE = 'Content-Type'.freeze
+  MULTIPART_FORM_DATA_RE = /^multipart\/form-data; boundary=(.+)$/.freeze
+  CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+  DISPOSITION_FORM_DATA_RE = /^form-data; name="([^"]+)"(; filename="([^"]+)")?$/.freeze
+  FORM_URL_ENCODED = 'application/x-www-form-urlencoded'.freeze
+  
+  # connection
+  CONNECTION = 'Connection'.freeze
+  KEEP_ALIVE = 'keep-alive'.freeze
+  CLOSE = 'close'.freeze
+  CONNECTION_CLOSE = "Connection: close\r\n".freeze
+  
+  # headers
+  HOST = 'Host'.freeze
+  X_FORWARDED_FOR = 'X-Forwarded-For'.freeze
+  DATE = 'Date'.freeze
+  LOCATION = 'Location'.freeze
+  
+  # caching
+  IF_NONE_MATCH = 'If-None-Match'.freeze
+  IF_MODIFIED_SINCE = 'If-Modified-Since'.freeze
+  ETAG = 'ETag'.freeze
+  LAST_MODIFIED = 'Last-Modified'.freeze
+  CACHE_CONTROL = 'Cache-Control'.freeze
+  NO_CACHE = 'no-cache'.freeze
+  EXPIRES = 'Expires'.freeze
+  
+  # response status
+  STATUS_OK = '200 OK'.freeze
+  STATUS_CREATED = '201 Created'.freeze
+  STATUS_ACCEPTED = '202 Accepted'.freeze
+  STATUS_NO_CONTENT = '204 No Content'.freeze
+  
+  STATUS_MOVED_PERMANENTLY = '301 Moved Permanently'.freeze
+  STATUS_FOUND = '302 Found'.freeze
+  STATUS_NOT_MODIFIED = '304 Not Modified'.freeze
+
+  STATUS_BAD_REQUEST = '400 Bad Request'.freeze
+  STATUS_UNAUTHORIZED = '401 Unauthorized'.freeze
+  STATUS_FORBIDDEN = '403 Forbidden'.freeze
+  STATUS_NOT_FOUND = '404 Not Found'.freeze
+  STATUS_METHOD_NOT_ALLOWED = '405 Method Not Allowed'.freeze
+  STATUS_NOT_ACCEPTABLE = '406 Not Acceptable'.freeze
+  STATUS_CONFLICT = '409 Conflict'.freeze
+  STATUS_REQUEST_ENTITY_TOO_LARGE = '413 Request Entity Too Large'.freeze
+  STATUS_REQUEST_URI_TOO_LONG = '414 Request-URI Too Long'.freeze
+  STATUS_UNSUPPORTED_MEDIA_TYPE = '415 Unsupported Media Type'.freeze
+  
+  STATUS_INTERNAL_SERVER_ERROR = '500 Internal Server Error'.freeze
+  STATUS_NOT_IMPLEMENTED = '501 Not Implemented'.freeze
+  STATUS_SERVICE_UNAVAILABLE = '503 Service Unavailable'.freeze
+  
+  # cookies
+  COOKIE = 'Cookie'.freeze
+  SET_COOKIE = 'Set-Cookie'.freeze
+  COOKIE_EXPIRED_TIME = Time.at(0).freeze
+end

data/lib/serverside/http/error.rb

@@ -0,0 +1,24 @@
+# StandardError extensions.
+class StandardError
+  # Returns the HTTP status code associated with the error class.
+  def http_status
+    ServerSide::HTTP::STATUS_INTERNAL_SERVER_ERROR
+  end
+  
+  # Sets the HTTP status code associated with the error class.
+  def self.set_http_status(value)
+    define_method(:http_status) {value}
+  end
+end
+
+module ServerSide::HTTP
+  # This error is raised when a malformed request is encountered.
+  class MalformedRequestError < RuntimeError
+    set_http_status STATUS_BAD_REQUEST
+  end
+  
+  # This error is raised when an invalid file is referenced.
+  class FileNotFoundError <  RuntimeError
+    set_http_status STATUS_NOT_FOUND
+  end
+end