serverside 0.2.9 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,59 @@
+==0.3.0
+
+* Disabled cluster_spec and parts of daemon_spec for now due to strange forking behavior.
+
+* Removed static file cache from Static.
+
+* Fixed daemon_spec to work correctly.
+
+* Removed all tests, moved specs to /spec, and fixed rakefile.
+
+* Converted cluster_test to cluster_spec.
+
+* Converted daemon_test to daemon_spec.
+
+* Updated specs to work with RSpec 0.7.
+
+* Changed rake spec task to do coverage as well.
+
+* Renamed controller.rb to controllers.rb.
+
+* Added String.underscore method.
+
+* Renamed ServerSide::Controller.process to response. 
+
+* Improved HTTP caching code to better conform to the HTTP spec. Also improved the validate_cache method to work without a block as well.
+
+* Removed unit tests that were converted to specs.
+
+* Router now excepts handlers to return non-nil if the request was handled. Otherwise, the request goes to the next handler with an appropriate rule.
+
+* Improved spec coverage for caching.
+
+* Wrote Server spec.
+
+* Wrote Router spec.
+
+* Refactored HTTP::Server to allow creating instances without starting them.
+
+* Fixed Router.routes_defined? to return non-nil if default route is defined.
+
+* Renamed Router.has_routes? to routes_defined?.
+
+* Fixed Static.serve_template and Static.serve_static to work correctly (render templates.)
+
+* Removed deprecated code in Template.render.
+
+* Wrote Static spec.
+
+* Fixed bug in serverside script - wrong call to route_default instead of default_route.
+
+* Refactored ServerSide::Template and wrote template spec.
+
+* Added documentation to Controller.
+
+* Fixed Controller.mount to build a self.inherited method, and do the routing there.
+
 ==0.2.9
 
 * Improved rake clean task.

data/Rakefile

@@ -2,12 +2,11 @@ require 'rake'
 require 'rake/clean'
 require 'rake/gempackagetask'
 require 'rake/rdoctask'
-require 'rake/testtask'
 require 'fileutils'
 include FileUtils
 
 NAME = "serverside"
-VERS = "0.2.9"
+VERS = "0.3.0"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "ServerSide Documentation",
   "--opname", "index.html",
@@ -47,7 +46,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('metaid')
   s.required_ruby_version = '>= 1.8.2'
 
-  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,test,lib}/**/*") 
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*") 
       
   s.require_path = "lib"
   s.bindir = "bin"
@@ -70,60 +69,23 @@ end
 desc 'Update docs and upload to rubyforge.org'
 task :doc_rforge do
   sh %{rake doc}
-  sh %{scp -r doc/rdoc/* ciconia@rubyforge.org:/var/www/gforge-projects/serverside}
-end
-
-desc 'Run unit tests'
-Rake::TestTask.new('test_unit') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/unit/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Run functional tests'
-Rake::TestTask.new('test_functional') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/functional/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Run specification tests'
-task :spec do
-  sh %{spec test/spec/*_spec.rb}
-end
-
-desc 'Run rcov'
-task :rcov do
-  sh %{rcov test/unit/*_test.rb test/functional/*_test.rb}
-end
-
-desc 'Run all tests'
-Rake::TestTask.new('test') do |t|
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Run all tests, specs and finish with rcov'
-task :aok do
-  sh %{rake rcov}
-  sh %{rake spec}
+  sh %{scp -r doc/* ciconia@rubyforge.org:/var/www/gforge-projects/serverside}
 end
 
 require 'spec/rake/spectask'
 
-desc "Run specs RCov"
-Spec::Rake::SpecTask.new('specs_with_rcov') do |t|
-  t.spec_files = FileList['test/spec/*_spec.rb']
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
   t.rcov = true
 end
 
-require 'spec/rake/rcov_verify'
+#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 = 'doc/output/coverage/index.html'
-end
+#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
 
 ##############################################################################
 # Statistics
@@ -131,9 +93,7 @@ end
 
 STATS_DIRECTORIES = [
   %w(Code                 lib/),
-  %w(Unit\ tests          test/unit),
-  %w(Functional\ tests    test/functional),
-  %w(Specification\ tests test/spec)
+  %w(Specification\ tests spec)
 ].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
 
 desc "Report code statistics (KLOCs, etc) from the application"

data/bin/serverside

@@ -76,7 +76,7 @@ if $cmd == 'serve'
   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)
+    ServerSide::Router).start
 else
   ServerSide::Application.daemonize($cmd_config, $cmd)
 end

data/lib/serverside/application.rb

@@ -15,7 +15,8 @@ module ServerSide
       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(config[:host], port, ServerSide::Router)
+          ServerSide::HTTP::Server.new(
+            config[:host], port, ServerSide::Router).start
         end
         meta_def(:ports) {config[:ports]}
       end

data/lib/serverside/caching.rb

@@ -4,21 +4,39 @@ module ServerSide
   module HTTP
     # This module implements HTTP cache negotiation with a client.
     module Caching
+      # HTTP headers
       ETAG = 'ETag'.freeze
+      LAST_MODIFIED = 'Last-Modified'.freeze
+      EXPIRES = 'Expires'.freeze
       CACHE_CONTROL = 'Cache-Control'.freeze
-      DEFAULT_MAX_AGE = (86400 * 30).freeze
+      VARY = 'Vary'.freeze
+      
       IF_NONE_MATCH = 'If-None-Match'.freeze
-      ETAG_WILDCARD = '*'.freeze
       IF_MODIFIED_SINCE = 'If-Modified-Since'.freeze
-      LAST_MODIFIED = "Last-Modified".freeze
-      NOT_MODIFIED_CLOSE = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nConnection: close\r\nLast-Modified: %s\r\nETag: \"%s\"\r\nCache-Control: max-age=%d\r\n\r\n".freeze
-      NOT_MODIFIED_PERSIST = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nLast-Modified: %s\r\nETag: \"%s\"\r\nCache-Control: max-age=%d\r\n\r\n".freeze
-      MAX_AGE = 'max-age=%d'.freeze
+      WILDCARD = '*'.freeze
+      
+      # Header values
+      NO_CACHE = 'no-cache'.freeze
       IF_NONE_MATCH_REGEXP = /^"?([^"]+)"?$/.freeze
-
-      # Returns an array containing all etags specified by the client in the
-      # If-None-Match header.
-      def cache_etags
+  
+      # etags
+      EXPIRY_ETAG_REGEXP = /(\d+)-(\d+)/.freeze
+      EXPIRY_ETAG_FORMAT = "%d-%d".freeze
+      ETAG_QUOTE_FORMAT = '"%s"'.freeze
+    
+      # 304 formats
+      NOT_MODIFIED_CLOSE = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nConnection: close\r\nContent-Length: 0\r\n\r\n".freeze
+      NOT_MODIFIED_PERSIST = "HTTP/1.1 304 Not Modified\r\nDate: %s\r\nContent-Length: 0\r\n\r\n".freeze
+      
+      def disable_caching
+        @response_headers[CACHE_CONTROL] = NO_CACHE
+        @response_headers.delete(ETAG)
+        @response_headers.delete(LAST_MODIFIED)
+        @response_headers.delete(EXPIRES)
+        @response_headers.delete(VARY)
+      end
+    
+      def etag_validators
         h = @headers[IF_NONE_MATCH]
         return [] unless h
         h.split(',').inject([]) do |m, i|
@@ -26,54 +44,48 @@ module ServerSide
         end
       end
       
-      # Returns the cache stamp specified by the client in the 
-      # If-Modified-Since header. If no stamp is specified, returns nil.
-      def cache_stamp
-        (h = @headers[IF_MODIFIED_SINCE]) ? Time.httpdate(h) : nil
-      rescue
+      def valid_etag?(etag = nil)
+        if etag
+          etag_validators.each {|e| return true if e == etag || e == WILDCARD}
+        else
+          etag_validators.each do |e|
+            return true if e == WILDCARD ||
+              ((e =~ EXPIRY_ETAG_REGEXP) && (Time.at($2.to_i) > Time.now))
+          end
+        end
         nil
       end
-
-      # Checks the request headers for validators and returns true if the
-      # client cache is valid. The validators can be either etags (specified
-      # in the If-None-Match header), or a modification stamp (specified in the
-      # If-Modified-Since header.)
-      def valid_client_cache?(etag, http_stamp)
-        none_match = @headers[IF_NONE_MATCH]
-        modified_since = @headers[IF_MODIFIED_SINCE]
-        (none_match && (none_match =~ /\*|"#{etag}"/)) ||
-          (modified_since && (modified_since == http_stamp))
+      
+      def expiry_etag(stamp, max_age)
+        EXPIRY_ETAG_FORMAT % [stamp.to_i, (stamp + max_age).to_i]
+      end
+      
+      def valid_stamp?(stamp)
+        return true if (modified_since = @headers[IF_MODIFIED_SINCE]) &&
+          (modified_since == stamp.httpdate)
       end
       
-      # Validates the client cache by checking any supplied validators in the
-      # request. If the client cache is not valid, the specified block is
-      # executed. This method also makes sure the correct validators are 
-      # included in the response - along with a Cache-Control header, to allow
-      # the client to cache the response. A possible usage:
-      # 
-      #   validate_cache("1234-5678", Time.now, 360) do
-      #     send_response(200, "text/html", body)
-      #   end
-      def validate_cache(etag, stamp, max_age = DEFAULT_MAX_AGE, &block)
-        http_stamp = stamp.httpdate
-        if valid_client_cache?(etag, http_stamp)
-          send_not_modified(etag, http_stamp, max_age)
+      def validate_cache(stamp, max_age, etag = nil, 
+        cache_control = nil, vary = nil, &block)
+        
+        if valid_etag?(etag) || valid_stamp?(stamp)
+          send_not_modified_response
+          true
         else
-          @response_headers[ETAG] = "\"#{etag}\""
-          @response_headers[LAST_MODIFIED] = http_stamp
-          @response_headers[CACHE_CONTROL] = MAX_AGE % max_age
-          block.call
+          @response_headers[ETAG] = ETAG_QUOTE_FORMAT %
+            [etag || expiry_etag(stamp, max_age)]
+          @response_headers[LAST_MODIFIED] = stamp.httpdate
+          @response_headers[EXPIRES] = (stamp + max_age).httpdate
+          @response_headers[CACHE_CONTROL] = cache_control if cache_control
+          @response_headers[VARY] = vary if vary
+          block ? block.call : nil
         end
       end
-
-      # Sends a 304 HTTP response, along with etag and stamp validators, and a
-      # Cache-Control header.
-      def send_not_modified(etag, http_time, max_age = DEFAULT_MAX_AGE)
-        @socket << ((@persistent ? NOT_MODIFIED_PERSIST : NOT_MODIFIED_CLOSE) % 
-          [Time.now.httpdate, http_time, etag, max_age])
+      
+      def send_not_modified_response
+        @socket << ((@persistent ? NOT_MODIFIED_PERSIST : NOT_MODIFIED_CLOSE) %
+          Time.now.httpdate)
       end
     end
   end
 end
-
-__END__

data/lib/serverside/controllers.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), 'routing')
+require 'rubygems'
+require 'metaid'
+
+module ServerSide
+  # Implements a basic controller class for handling requests. Controllers can
+  # be mounted by using the Controller.mount  
+  class Controller
+    # Creates a subclass of Controller which adds a routing rule when 
+    # subclassed. For example:
+    #
+    #   class MyController < ServerSide::Controller.mount('/ohmy')
+    #     def response
+    #       render('Hi there!', 'text/plain')
+    #     end
+    #   end
+    #
+    # You can of course route according to any rule as specified in
+    # ServerSide::Router.route, including passing a block as a rule, e.g.:
+    #
+    #   class MyController < ServerSide::Controller.mount {@headers['Accept'] =~ /wap/}
+    #     ...
+    #   end
+    def self.mount(rule = nil, &block)
+      rule ||= block
+      raise ArgumentError, "No routing rule specified." if rule.nil?
+      Class.new(self) do
+        meta_def(:inherited) do |sub_class|
+          ServerSide::Router.route(rule) {sub_class.new(self)}
+        end
+      end
+    end
+    
+    # Initialize a new controller instance. Sets @request to the request object
+    # and copies both the request path and parameters to instance variables.
+    # After calling response, this method checks whether a response has been sent
+    # (rendered), and if not, invokes the render_default method. 
+    def initialize(request)
+      @request = request
+      @path = request.path
+      @parameters = request.parameters
+      response
+      render_default if not @rendered
+    end
+    
+    # Renders the response. This method should be overriden.
+    def response
+    end
+    
+    # Sends a default response.
+    def render_default
+      @request.send_response(200, 'text/plain', 'no response.')
+    end
+    
+    # Sends a response and sets @rendered to true.
+    def render(body, content_type)
+      @request.send_response(200, content_type, body)
+      @rendered = true
+    end
+  end
+end
+
+__END__
+
+class ServerSide::ActionController < ServerSide::Controller
+  def self.default_routing_rule
+    if name.split('::').last =~ /(.+)Controller$/
+      controller = Inflector.underscore($1) 
+      {:path => ["/#{controller}", "/#{controller}/:action", "/#{controller}/:action/:id"]}
+    end
+  end
+
+  def self.inherited(c)
+    routing_rule = c.respond_to?(:routing_rule) ?
+      c.routing_rule : c.default_routing_rule
+    if routing_rule
+      ServerSide::Router.route(routing_rule) {c.new(self)}
+    end
+  end
+  
+  def self.route(arg = nil, &block)
+    rule = arg || block
+    meta_def(:get_route) {rule}
+  end
+end
+
+class MyController < ActionController
+  route "hello"
+end
+
+p MyController.get_route

data/lib/serverside/core_ext.rb

@@ -15,6 +15,12 @@ class String
   def /(o)
     File.join(self, o.to_s)
   end
+
+  # Converts camel-cased phrases to underscored phrases.
+  def underscore
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").downcase
+  end
 end
 
 # Symbol extensions and overrides.

data/lib/serverside/daemon.rb

@@ -1,5 +1,15 @@
 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
@@ -24,6 +34,10 @@ module Daemon
     rescue
       raise 'Pid not found. Is the daemon started?'
     end
+    
+    def self.remove(daemon)
+      FileUtils.rm(daemon.pid_fn) if File.file?(daemon.pid_fn)
+    end
   end
   
   # Controls a daemon according to the supplied command or command-line 
@@ -50,18 +64,24 @@ 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
   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)
+    PidFile.remove(daemon)
+  end
+
+  def self.alive?(daemon)
+    pid = PidFile.recall(daemon) rescue nil
+    return nil if !pid
+    `ps #{pid}` =~ /#{pid}/ ? true : nil
   end
 end

data/lib/serverside/request.rb

@@ -123,15 +123,16 @@ module ServerSide
           @parameters.merge! parse_parameters(@body)
         elsif @content_type =~ MULTIPART_REGEXP
           boundary = "--#$1"
-          @body.split(/(?:\r?\n|\A)#{Regexp::quote(boundary)}(?:--)?\r\n/m).each do |pt|
+          r = /(?:\r?\n|\A)#{Regexp::quote("--#$1")}(?:--)?\r\n/m
+          @body.split(r).each do |pt|
             headers, payload = pt.split("\r\n\r\n", 2)
             atts = {}
             if headers =~ CONTENT_DISPOSITION_REGEXP
-              $1.split(';').map {|part|
+              $1.split(';').map do |part|
                 if part =~ FIELD_ATTRIBUTE_REGEXP
                   atts[$1.to_sym] = $2
                 end
-              }
+              end
             end
             if headers =~ CONTENT_TYPE_REGEXP
               atts[:type] = $1
@@ -150,16 +151,17 @@ module ServerSide
         @response_headers.merge!(headers) if headers
         h = @response_headers.inject('') {|m, kv| m << (HEADER % kv)}
         
-        # calculate content_length if needed. if we dont have the content_length,
-        # we consider the response as a streaming response, and so the connection
-        # will not be persistent.
+        # calculate content_length if needed. if we dont have the 
+        # content_length, we consider the response as a streaming response, 
+        # and so the connection will not be persistent.
         content_length = body.length if content_length.nil? && body
         @persistent = false if content_length.nil?
         
         # Select the right format to use according to circumstances.
         @socket << ((@persistent ? STATUS_PERSIST : 
           (body ? STATUS_CLOSE : STATUS_STREAM)) % 
-          [status, Time.now.httpdate, content_type, h, @response_cookies, content_length])
+          [status, Time.now.httpdate, content_type, h, @response_cookies, 
+            content_length])
         @socket << body if body
       rescue
         @persistent = false
@@ -168,8 +170,10 @@ module ServerSide
       CONTENT_DISPOSITION = 'Content-Disposition'.freeze
       CONTENT_DESCRIPTION = 'Content-Description'.freeze
 
-      def send_file(content, content_type, disposition = :inline, filename = nil, description = nil)
-        disposition = filename ? "#{disposition}; filename=#{filename}" : "#{disposition}"
+      def send_file(content, content_type, disposition = :inline, 
+        filename = nil, description = nil)
+        disposition = filename ?
+          "#{disposition}; filename=#{filename}" : disposition
         @response_headers[CONTENT_DISPOSITION] = disposition
         @response_headers[CONTENT_DESCRIPTION] = description if description
         send_response(200, content_type, content)
@@ -192,10 +196,12 @@ module ServerSide
       # Sets a cookie to be included in the response.
       def set_cookie(name, value, expires)
         @response_cookies ||= ""
-        @response_cookies << (SET_COOKIE % [name, value.to_s.uri_escape, expires.rfc2822])
+        @response_cookies <<
+          (SET_COOKIE % [name, value.to_s.uri_escape, expires.rfc2822])
       end
       
-      # Marks a cookie as deleted. The cookie is given an expires stamp in the past.
+      # Marks a cookie as deleted. The cookie is given an expires stamp in 
+      # the past.
       def delete_cookie(name)
         set_cookie(name, nil, COOKIE_EXPIRED_TIME)
       end

data/lib/serverside/routing.rb

@@ -22,9 +22,11 @@ module ServerSide
   # Routing rules are evaluated backwards, so the rules should be ordered
   # from the general to the specific.
   class Router < HTTP::Request
+    @@rules = []
+  
     # Returns true if routes were defined.
-    def self.has_routes?
-      @@rules && !@@rules.empty? rescue false
+    def self.routes_defined?
+      !@@rules.empty? || @@default_route
     end
     
     # Adds a routing rule. The normalized rule is a hash containing keys (acting
@@ -36,7 +38,6 @@ module ServerSide
     #
     #   ServerSide.route(lambda{path = 'mypage'}) {serve_static('mypage.html')}
     def self.route(rule, &block)
-      @@rules ||= []
       rule = {:path => rule} unless (Hash === rule) || (Proc === rule)
       @@rules.unshift [rule, block]
       compile_rules
@@ -45,7 +46,6 @@ module ServerSide
     # Compiles all rules into a respond method that is invoked when a request
     # is received.
     def self.compile_rules
-      @@rules ||= []
       code = @@rules.inject('lambda {') {|m, r| m << rule_to_statement(r[0], r[1])}
       code << 'default_handler}'
       define_method(:respond, &eval(code))
@@ -66,15 +66,15 @@ module ServerSide
           end
         }.join('&&')
       end
-      "return #{proc_tag} if #{cond}\n"
+      "if #{cond} && (r = #{proc_tag}); return r; end\n"
     end
 
-    # Pattern for finding parameters inside patterns. Parameters are parts of the
-    # pattern, which the routing pre-processor turns into sub-regexp that are
-    # used to extract parameter values from the pattern.
+    # Pattern for finding parameters inside patterns. Parameters are parts 
+    # of the pattern, which the routing pre-processor turns into sub-regexp 
+    # that are used to extract parameter values from the pattern.
     #
-    # For example, matching '/controller/show' against '/controller/:action' will
-    # give us @parameters[:action] #=> "show"
+    # For example, matching '/controller/show' against '/controller/:action'
+    # will give us @parameters[:action] #=> "show"
     ParamRegexp = /(?::([a-z]+))/
 
     # Returns the condition part for the key and value specified. The key is the
@@ -117,6 +117,7 @@ module ServerSide
 
     # Sets the default handler for incoming requests.
     def self.default_route(&block)
+      @@default_route = block
       define_method(:default_handler, &block)
       compile_rules
     end

data/lib/serverside/server.rb

@@ -6,13 +6,21 @@ module ServerSide
     # 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 
-      # supplied connection class is instantiated and passed the connection for
-      # processing.
+      attr_reader :listener
+
+      # Creates a new server by opening a listening socket.
       def initialize(host, port, request_class)
-        @server = TCPServer.new(host, port)
-        loop {Connection.new(@server.accept, request_class)}
+        @request_class = request_class
+        @listener = TCPServer.new(host, port)
+      end
+      
+      # starts an accept loop. When a new connection is accepted, a new 
+      # instance of the supplied connection class is instantiated and passed 
+      # the connection for processing.
+      def start
+        while true
+          Connection.new(@listener.accept, @request_class)
+        end
       end
     end
   end