raw 0.49.0

data/lib/raw/adapter/script.rb

@@ -0,0 +1,94 @@
+require "raw/adapter"
+
+module Raw
+
+# The script adapter. Useful when running in console mode, or
+# when creating scripts for cron jobs, testing and more. Allows
+# you to programmatically 'drive' the web application.
+
+class ScriptAdapter < Adapter
+  include AdapterHandlerMixin
+
+  # The last generated response.
+  
+  attr_accessor :response
+  
+  def start(application)
+    info "This console  is attached to the application context."
+    info ""
+    info "* $app points to the application"
+    info "* $srv points to the adapter"
+    info "* use get(uri), post(uri), response() to programmatically call actions"
+    info ""
+    
+    $app = $application = @application = application
+    $srv = $adapter = self
+  end
+  
+  # Perform a programatic http request to the web app.
+  #
+  # === Examples
+  #
+  # $srv.get 'users/logout'
+  # $srv.post 'users/login', :params => { :name => 'gmosx', :password => 'pass' }
+  # $srv.post 'users/login?name=gmosx;password=pass
+  # $srv.post 'articles/view/1'
+  
+  def handle(uri, options = {})
+    # Perform default rewriting rules.
+    # rewrite(req)
+
+    context = Context.new(@application)
+    
+    context.get_params = options.fetch(:get_params, {})
+    context.post_params = options.fetch(:post_params, {})
+    context.headers = options.fetch(:headers, {})
+ 
+    context.headers["REQUEST_URI"] = uri
+    context.headers["REQUEST_METHOD"] = options.fetch(:method, :get)
+    context.headers["HTTP_COOKIE"] ||= options[:cookies]
+          
+    handle_context(context)
+  
+    @response = context
+
+    context.close
+    
+    return context
+  end
+  
+  # Perform a programmatic http get request to the web app.
+   
+  def get(uri, options = {})
+    options[:method] = "get"
+    handle(uri, options)
+  end
+
+  # Perform a programmatic http post request to the web app.
+   
+  def post(uri, options = {})
+    options[:method] = "post"
+    handle(uri, options)
+  end
+    
+end
+
+end
+
+# Add some convienience methods.
+
+if ENV["NITRO_ADAPTER"] == "script"
+
+def get(*args)
+  $srv.get(*args)
+end
+
+def post(*args)
+  $srv.post(*args)
+end
+
+def response
+  $srv.response
+end
+
+end

data/lib/raw/adapter/webrick.rb

@@ -0,0 +1,144 @@
+require "stringio"
+require "webrick"
+
+require "raw/adapter"
+
+module Raw
+
+# A Webrick Adapter for Nitro. Webrick is a pure Ruby web server
+# included in the default Ruby distribution. The Webrick Adapter
+# is the prefered adapter in development/debug environments. It
+# is also extremely easy to setup.
+#
+# However, for live/production environments, you should prefer
+# a more performant adapter like Mongrel or FCGI. Mongrel is the
+# suggested adapter for production applications.
+
+class WebrickAdapter < Adapter
+
+  class Swallow # :nodoc: all
+    def self.method_missing(*args)
+      # drink it!
+    end
+  end
+
+  # Start the adapter.
+  
+  def start(app)
+    super
+    
+    if RUBY_PLATFORM !~ /mswin32/
+      wblog = WEBrick::BasicLog::new("/dev/null")
+    elsif File.exist? "log"
+      wblog = WEBrick::BasicLog::new("log/access.log")
+    else
+      wblog = STDERR
+    end
+
+    webrick_options = app.options.dup
+    
+    require "webrick/https" if webrick_options[:SSLEnable]
+
+    webrick_options.update(
+      :BindAddress => app.address, 
+      :Port => app.port, 
+      :DocumentRoot => app.public_dir,
+      :Logger => Swallow,
+      :AccessLog => [
+        [wblog, WEBrick::AccessLog::COMMON_LOG_FORMAT],
+        [wblog, WEBrick::AccessLog::REFERER_LOG_FORMAT]
+      ]
+    )
+
+    trap("INT") { stop }
+    
+    @webrick = WEBrick::HTTPServer.new(webrick_options)
+    @webrick.mount("/", WebrickHandler, app)
+    @webrick.start
+  end
+  
+  # Stop the adapter.
+  
+  def stop
+    super
+    @webrick.shutdown
+  end
+
+end
+
+# The Webrick Handler, handles an HTTP request.
+#--
+# TODO: add some way to prevent the display of template files
+# if the public dir is used as the template dir.
+#++
+
+class WebrickHandler < WEBrick::HTTPServlet::AbstractServlet
+  include WEBrick
+  include AdapterHandlerMixin
+
+  def initialize(webrick, app)
+    @application = app
+
+    # Handles static resources. Useful when running 
+    # a stand-alone webrick server.
+
+    @file_handler = WEBrick::HTTPServlet::FileHandler.new(
+      webrick, app.public_dir, app.options
+    )
+  end
+
+  # Handle a static file. Also handles cached pages. Typically
+  # *not* used in production applications.
+  
+  def handle_file(req, res)
+    return false unless @application.handle_static_files    
+    @file_handler.do_GET(req, res)
+    return true
+  rescue WEBrick::HTTPStatus::PartialContent, WEBrick::HTTPStatus::NotModified => err
+    res.set_error(err)
+    return true
+  rescue WEBrick::HTTPStatus::NotFound => ex
+    return false
+  end
+
+  # Handle the request.
+
+  def handle(req, res)
+    # Perform default rewriting rules.
+    
+    rewrite(req)
+
+    # First, try to serve a static file from disk.
+
+    return if handle_file(req, res)
+
+    # No static file found, attempt to dynamically generate 
+    # a response.
+    
+    context = Context.new(@application)
+
+    context.in = StringIO.new(req.body || "")
+
+    context.headers = {}
+    req.header.each { |h, v| context.headers[h.upcase] = v.first }
+    context.headers.update(req.meta_vars)
+
+    # gmosx: make compatible with fastcgi.
+      
+    context.headers["REQUEST_URI"].slice!(/http:\/\/(.*?)\//)
+    context.headers["REQUEST_URI"] = '/' + context.headers['REQUEST_URI']
+
+    res.body = handle_context(context)
+    
+    res.status = context.status
+    res.instance_variable_set(:@header, context.response_headers || {})
+    res.instance_variable_set(:@cookies, context.response_cookies || {})
+      
+    context.close
+  end
+
+  alias_method :do_GET, :handle 
+  alias_method :do_POST, :handle
+end
+
+end

data/lib/raw/adapter/webrick/vcr.rb

@@ -0,0 +1,91 @@
+require "raw/adapter/webrick"
+
+module Raw
+
+class WebrickAdapter < Adapter
+
+  def setup(server)
+    if $record_session_filename
+      require "raw/adapter/webrick/vcr"
+      vcr_record($record_session_filename)
+    end
+    
+    if $playback_session_filename
+      require "raw/adapter/webrick/vcr"
+      vcr_playback($playback_session_filename)
+    end
+  end
+
+  # Enables session recording. The recorded data can be used 
+  # for automatic app testing by means of the playback mode.
+  
+  def vcr_record(filename = "session.yaml")
+    info "Recording application server session to '#{filename}'."
+    
+    require "facets/core/file/self/create"
+
+    $record_session = []
+    $last_record_time = Time.now
+
+    Nitro::WebrickHandler.class_eval do   
+      def do_GET(req, res)
+        record_context(req, res)
+        handle(req, res)
+      end
+      alias_method :do_POST, :do_GET
+
+      def record_context(req, res)
+        delta = Time.now - $last_record_time
+        $last_record_time = Time.now
+        $record_session << [delta, req, res]
+      end          
+    end
+
+    at_exit do
+      File.create(filename, YAML.dump($record_session))
+    end
+  end
+  
+  # Playback a recorded session. Typically used for testing.
+  
+  def vcr_playback(filename = "session.yaml")
+    info "Playing back application server session from '#{filename}'."
+    
+    $playback_session = YAML.load_file(filename)
+    $playback_exception_count = 0
+        
+    WEBrick::HTTPServer.class_eval do
+      def start(&block)
+        run(nil)
+      end
+      
+      def run(sock)
+        while true
+          delta, req, res = $playback_session.shift
+          
+          if delta
+            sleep(delta)
+            begin
+              service(req, res)
+            rescue Object => ex
+              $playback_exception_count += 1
+              p "---", ex                
+            end
+          else
+            return
+          end
+        end
+      end
+    end
+    
+    at_exit do
+      puts "\n\n"
+      puts "Playback raised #$playback_exception_count exceptions.\n"
+      puts "\n"
+    end
+  end
+
+end
+
+end
+

data/lib/raw/cgi.rb

@@ -0,0 +1,323 @@
+require "cgi"
+require "stringio"
+
+require "facets/more/settings"
+
+require "raw/cgi/http"
+
+module Raw
+
+# Nitro CGI (Common Gateway Interface) methods. Typically 
+# handles HTTP Request parsing and HTTP Response generation.
+
+class Cgi
+  include Http
+
+  # Maximum content length allowed in requests.
+
+  setting :max_content_length, :default => (2 * 1024 * 1024), :doc => 'Maximum content length allowed in requests'
+
+  # Multipart parsing buffer size.
+
+  setting :buffer_size, :default => (10 * 1024), :doc => 'Multipart parsing buffer size'
+
+  # Process a CGI request. This is a general method reused by
+  # many adapters.
+  #--
+  # A CGI request is process-based so there is no need for Og
+  # connection cleanup.
+  #++
+  
+  def self.process(server, cgi, inp, out)
+    context = Context.new(server)
+
+    unless inp.respond_to?(:rewind)
+      # The module Request#raw_body requires a rewind method,
+      # so if the input stream doesn't have one, *cough* FCgi,
+      # we convert it to a StringIO.
+
+      inp = StringIO.new(inp.read.to_s) # if read returns nil, to_s makes it ""
+    end
+
+    context.in = inp
+    context.headers = cgi.env
+
+    #--
+    # gmosx: only handle nitro requests.
+    #++
+    # gmosx: QUERY_STRING is sometimes not populated.
+
+    if context.query_string.empty? and context.uri =~ /\?/
+      context.headers['QUERY_STRING'] = context.uri.split('?').last
+    end
+
+    Cgi.parse_params(context)
+    Cgi.parse_cookies(context)
+    context.render(context.path)
+
+    out.print(Cgi.response_headers(context))
+    
+    if context.out.is_a?(IO)
+      begin
+        while buf = context.out.read(4096)
+          out.write(buf)
+        end
+      ensure
+        context.out.close
+      end
+    else
+      out.print(context.out)
+    end
+
+    $autoreload_dirty = false
+      
+    context.close    
+  end
+
+  # push a parameter into the params hash
+
+  def self.structure_param(params, key, val)
+    if key =~ /(.+)\[(.+)\]$/ or key =~ /([^\.]+)\.(.+)$/
+      params[$1] ||= Dictionary.new
+      params[$1] = structure_param(params[$1], $2, val)
+    elsif key =~ /(.+)\[\]$/
+      params[$1] ||= Array.new
+      params[$1] << val.to_s
+    else
+      params[key] = val.nil? ? nil : val
+    end
+    return params
+  end
+
+  # Returns a hash with the pairs from the query 
+  # string. The implicit hash construction that is done 
+  # in parse_request_params is not done here.
+  
+  def self.parse_query_string(query_string)
+    params = Dictionary.new
+    
+    # gmosx, THINK: better return nil here?
+    return params if (query_string.nil? or query_string.empty?)
+
+    query_string.split(/[&;]/).each do |p| 
+      key, val = p.split('=')
+      
+      key = CGI.unescape(key) unless key.nil?
+      val = CGI.unescape(val) unless val.nil?
+      
+      params = self.structure_param(params, key, val)
+    end
+    
+    return params
+  end
+
+  # Parse the HTTP_COOKIE header and returns the
+  # cookies as a key->value hash. For efficiency no 
+  # cookie objects are created.
+  #
+  # [+context+]
+  #    The context 
+
+  def self.parse_cookies(context) 
+    env = context.env
+
+    # FIXME: dont precreate?
+    context.cookies = {}
+
+    #if env.has_key?('HTTP_COOKIE') or env.has_key?('COOKIE')
+    if env['HTTP_COOKIE'] or env['COOKIE']
+      (env['HTTP_COOKIE'] or env['COOKIE']).split(/; /).each do |c|
+        key, val = c.split(/=/, 2)
+        val ||= ""
+        key = CGI.unescape(key)
+        val = val.split(/&/).collect{|v| CGI::unescape(v)}.join("\0")
+
+        if context.cookies.include?(key)
+          context.cookies[key] += "\0" + val
+        else
+          context.cookies[key] = val
+        end
+      end
+    end
+  end
+
+  # Build the response headers for the context. 
+  #
+  # [+context+]
+  #    The context of the response.
+  #
+  # [+proto+]
+  #    If true emmit the protocol line. Useful for MOD_RUBY.
+  #--
+  # FIXME: return the correct protocol from env.
+  # TODO: Perhaps I can optimize status calc.
+  #++
+                                                                                      
+  def self.response_headers(context, proto = false)
+    reason = STATUS_STRINGS[context.status] 
+
+    if proto
+      buf = "HTTP/1.1 #{context.status} #{reason}#{EOL}Date: #{CGI::rfc1123_date(Time.now)}#{EOL}"
+    else
+      buf = "Status: #{context.status} #{reason}#{EOL}"
+    end
+
+    context.response_headers.each do |key, value|
+      tmp = key.gsub(/\bwww|^te$|\b\w/) { |s| s.upcase }
+      buf << "#{tmp}: #{value}" << EOL
+    end
+  
+    context.response_cookies.each do |cookie|
+      buf << "Set-Cookie: " << cookie.to_s << EOL
+    end if context.response_cookies
+      
+    buf << EOL
+
+    return buf
+  end
+  
+  # Initialize the request params.
+  # Handles multipart forms (in particular, forms that involve 
+  # file uploads). Reads query parameters in the @params field, 
+  # and cookies into @cookies.
+  
+  def self.parse_params(context)
+    method = context.method
+    if (:post == method) and
+        %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(context.headers['CONTENT_TYPE'])
+      boundary = $1.dup
+      context.post_params = parse_multipart(context, boundary)
+
+      # Also include the URI parameters.
+      context.get_params.update(Cgi.parse_query_string(context.query_string))      
+    else 
+      case method
+      when :get, :head
+        context.get_params = Cgi.parse_query_string(context.query_string)  
+      when :post
+        context.in.binmode if defined?(context.in.binmode)
+        context.post_params = Cgi.parse_query_string(context.in.read(context.content_length) || '')  
+      end
+    end
+  end
+
+  # Parse a multipart request.
+  # Adapted from Ruby's cgi.rb
+  #--
+  # TODO: optimize and rationalize this.
+  #++
+
+  def self.parse_multipart(context, boundary)
+    input = context.in
+    content_length = context.content_length
+    env_table = context.env
+    
+    params = Hash.new()
+    boundary = "--" + boundary
+    quoted_boundary = Regexp.quote(boundary, "n")
+    buf = ""
+    boundary_end=""
+    
+    # start multipart/form-data
+    input.binmode if defined? input.binmode
+    boundary_size = boundary.size + EOL.size
+    content_length -= boundary_size
+    status = input.read(boundary_size)
+
+    if nil == status
+      raise EOFError, "no content body"
+    elsif boundary + EOL != status
+      raise EOFError, "bad content body"
+    end
+
+    loop do
+      head = nil
+
+      if 10240 < content_length
+        body = Tempfile.new("CGI")
+      else
+        begin
+          require "stringio"
+          body = StringIO.new
+        rescue LoadError
+          body = Tempfile.new("CGI")
+        end
+      end
+      body.binmode if defined? body.binmode
+
+      until head and /#{quoted_boundary}(?:#{EOL}|--)/n.match(buf)
+
+        if (not head) and /#{EOL}#{EOL}/n.match(buf)
+          buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+            head = $1.dup
+            ""
+          end
+          next
+        end
+
+        if head and ( (EOL + boundary + EOL).size < buf.size )
+          body.print buf[0 ... (buf.size - (EOL + boundary + EOL).size)]
+          buf[0 ... (buf.size - (EOL + boundary + EOL).size)] = ""
+        end
+
+        c = if Cgi.buffer_size < content_length
+              input.read(Cgi.buffer_size)
+            else
+              input.read(content_length)
+            end
+        if c.nil? || c.empty?
+          raise EOFError, "bad content body"
+        end
+        buf.concat(c)
+        content_length -= c.size
+      end
+
+      buf = buf.sub(/\A((?:.|\n)*?)(?:[\r\n]{1,2})?#{quoted_boundary}([\r\n]{1,2}|--)/n) do
+        body.print $1
+        if "--" == $2
+          content_length = -1
+        end
+        boundary_end = $2.dup
+        ""
+      end
+
+      body.rewind
+
+      /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+      
+      filename = ($1 or "")
+
+      if /Mac/ni.match(env_table['HTTP_USER_AGENT']) and
+          /Mozilla/ni.match(env_table['HTTP_USER_AGENT']) and
+          (not /MSIE/ni.match(env_table['HTTP_USER_AGENT']))
+        filename = CGI::unescape(filename)
+      end
+      
+      /Content-Type: (.*)/ni.match(head)
+      content_type = ($1 or "")
+
+      (class << body; self; end).class_eval do
+        alias_method :local_path, :path
+        define_method(:original_filename) { filename.dup.taint }
+        define_method(:content_type) { content_type.dup.taint }
+
+        # gmosx: this hides the performance hit!!
+        define_method(:to_s) { str = read; rewind; return str}
+      end
+
+      /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+      name = $1.dup
+      
+      params = self.structure_param(params, name, body)
+
+      break if buf.size == 0
+      break if content_length === -1
+    end
+    raise EOFError, "bad boundary end of body" unless boundary_end =~ /--/
+
+    return params
+  end
+  
+end
+  
+end